Index

A

• access control list (ACL) / Authorizing users
• access property / Objects, properties, and property attributes
• access property, attributes
  • get accessor / Objects, properties, and property attributes
  • set accessor / Objects, properties, and property attributes
  • enumerable / Objects, properties, and property attributes
  • configurable / Objects, properties, and property attributes
• Active Directory / Authenticating users
• Actuator, Spring Boot
  • about / Spring Boot Actuator
  • health endpoint / The health endpoint
  • info endpoint / The info endpoint
  • metrics endpoint / The metrics endpoint
  • environment endpoint / The environment endpoint
  • endpoint security / Endpoint security
• advices
  • about / Advices
  • before advice / Advices
  • after returning advice / Advices
  • after throwing advice / Advices
  • after advice / Advices
  • around advice / Advices
• agile code design / Agile code design
• agile code design, at implementation level
  • test-driven development / Implementation level
  • acceptance tests / Implementation level
  • refactoring / Implementation level
  • current stories, focusing on / Implementation level
• agile code design, best practices
  • about / Agile code design practices
  • architecture level / Architecture level
  • abstraction level / Abstraction level
  • implementation level / Implementation level
• agile manifesto
  • reference / Understanding Agile
  • values / The Agile manifesto
  • individuals and interactions / Individuals and interactions over processes and tools
  • working software / Working software over comprehensive documentation
  • customer collaboration / Customer collaboration over contract negotiation
  • responding to change / Responding to change over following a plan
• agile methodologies / Understanding Agile
• agile project
  • requirements, writing / Writing a requirement in an Agile project
• AMQP
  • activity, tracking asynchronously / Tracking activity asynchronously with AMQP
  • card cover images, adding / Adding card cover images and activity tracking
  • activity, tracking / Adding card cover images and activity tracking
• anemic domain models / Layered architecture
• annotation-based configuration
  • about / Annotation-based configuration
  • bean, declaration / Bean declaration
  • dependency injection / Dependency injection
• AOP proxy
  • creating / AOP proxy
• APIs, board page
  • Get board API / APIs for the board page
  • board member API / APIs for the board page
  • card list API / APIs for the board page
  • card list positions API / APIs for the board page
  • card API / APIs for the board page
  • card positions API / APIs for the board page
• APIs, for card modal
  • about / APIs for the card modal
  • get card API / Get card API
  • change card title API / Change card title API
  • change card description API / Change card description API
  • add comment API / Add comment API
  • get activities API / Get activities API
  • add attachment API / Add attachment API
  • get attachments API / Get attachments API
• applications as a service
  • installing / Installing as a service
• architectural constraints, REST
  • about / REST architectural constraints
  • client-server / Client-server
  • stateless / Stateless
  • cache / Cache
  • uniform interface / Uniform interface
  • layered system / Layered system
  • code-on-demand (optional) / Code-on-demand (optional)
• array destructuring / Array destructuring
• arrow functions
  • about / Arrow functions
  • without this keyword / No lexical this
  • without prototype object / No prototype object
• AspectJ
  • reference / Aspects
• AssertJ / Unit testing of the Messages App
• attributes / Attributes
• authentication, Spring Security
  • about / Spring Security authentication in depth
  • SecurityContextPersistenceFilter / SecurityContextPersistenceFilter
  • UsernamePasswordAuthenticationFilter / UsernamePasswordAuthenticationFilter
• authorization, Spring Security
  • about / Spring Security authorization in depth
  • FilterSecurityInterceptor / FilterSecurityInterceptor
  • method security / Method security 
• autoconfiguration, Spring Boot
  • reference / Autoconfiguration
• automation tests / Maturity and cost
• autosize
  • reference / Implement auto-resize of card title editing
• axios
  • reference / HTTP client – axios, HTTP client
  • using / HTTP client – axios, HTTP client

B

• Babel
  • using / Introduction
  • reference / Modules
• backend, board page
  • building / Building the backend of the board page
  • APIs / APIs for the board page
  • positions, modifying / Changing positions in batch
• backend, card modal
  • building / Building the backend of the card modal
  • APIs / APIs for the card modal
  • uploaded file, saving / Saving the uploaded file
  • thumbnails, generating for images / Generating thumbnails for images
  • files, storing to S3 / Storing files to S3
• backend APIs, home page frontend
  • about / Backend APIs
  • personal board API, creating / Creating a personal board API
  • team API, creating / Creating the team API
  • team board API, creating / Creating team board API
  • combining / A combined API to get the user's name, boards, and teams
• backend scaffold
  • creating, with Spring Initializr / Creating the backend scaffold with Spring Initializr
• backend validation
  • implementing / Validation on the backend
  • RegistrationPayload class, creating / Creating RegistrationPayload
  • RegistrationApiController class, creating / Create RegistrationApiController
• bad code design
  • symptoms / Symptoms of bad design
  • rigidity / Symptoms of bad design, Rigidity
  • fragility / Symptoms of bad design, Fragility
  • immobility / Symptoms of bad design, Immobility
  • viscosity / Symptoms of bad design, Viscosity
  • needless complexity / Symptoms of bad design
  • needless repetition / Symptoms of bad design
  • opacity / Symptoms of bad design, Opacity
• beans / Spring IoC and dependency injection
• block level scope / Block scoping, let, and const
• bluebird
  • reference / Promises
  • about / Promises
• board page
  • frontend, building / Building the frontend of the board page
  • backend, building / Building the backend of the board page
  • error, handling / Fixes at the end
• Bootstrap 4
  • reference / Building a UI with Bootstrap 4
  • UI, building / Building a UI with Bootstrap 4
  • using / Install and use Bootstrap
  • installing / Install and use Bootstrap
  • UI, implementing of register page / Implement the UI of the register page
• Bootstrap modal
  • popup windows, implementing / Implementing popup windows with Bootstrap modal
• build life cycle, Maven
  • reference / Building with a single command

C

• candidate keys / Primary keys
• card modal
  • frontend, building / Building the frontend of the card modal
  • UI, building / The UI of the card modal window
  • layout, designing / The layout of the card modal window
  • router, implementing for board URL and card URL / Router for board URL and card URL
  • auto-resize, implementing of card title editing / Implement auto-resize of card title editing
  • Markdown format, implementing / Implementing support of the Markdown format
  • file uploads, implementing / Implementing file uploads
  • backend, building / Building the backend of the card modal
  • error, handling / Fixes at the end
• Central Authentication Service (CAS) / Single Sign-On
• Certbot
  • reference / Installing NGINX and the SSL certificate
• CGLIB
  • reference / AOP proxy
• Chain of Responsibility design pattern / Filters
• channel-based communication pattern
  • building / The channel-based communication pattern
  • real-time client frontend, implementing / Frontend implementation of the real-time client
  • real-time client, authenticating with JWT / Authenticating a real-time client with JWT
  • server, implementing / Server implementation of channel handlers
• characteristics, opinionated RESTful API
  • about / Opinionated RESTful API characteristics
  • resource-centric / Resource-centric
  • identifiable through URIs / Identifiable through URIs
  • operations, defining via HTTP methods / Defining operations via HTTP methods
  • HTTP status codes, using / Use of HTTP status codes
  • versioning / Versioning
  • stateless / Stateless
  • pagination / Pagination
  • search / Searching and sorting
  • sort / Searching and sorting
  • security / Security
• classes
  • about / Objects and classes
  • in ECMAScript 2015 (ES6) / Classes
• closure / Scope and closure
• code design
  • about / What is code design?
  • reference / What is code design?
  • traditional angle / Traditional angle
  • second angle / A second angle
  • angles, differences between / Differences between the two angles
  • level / Levels of code design
  • limitations, with details / Devil in the details
  • bad design, symptoms / Symptoms of bad design
• code design, TaskAgile application
  • about / TaskAgile code design
  • layered architecture / Layered architecture
  • hexagonal architecture / Hexagonal architecture
• components
  • in Vue.js / Components
• Conceptual Data Model / Physical data modeling
• conceptual data modeling
  • about / Conceptual data modeling
  • with ER diagrams / Conceptual data modeling with ER diagrams
• conditional configuration / Autoconfiguration
• const / Block scoping, let, and const
• constructor-based injection / Constructor-based injection
• continuous delivery
  • about / Continuous delivery
  • registration API, integration testing / Registration API integration test
  • maturity / Maturity and cost
  • cost / Maturity and cost
  • E2E tests, refactoring / Refactoring E2E tests
  • building, with Jenkins / Let's ship it
• Continuous Delivery (CD) / RESTful API testing
• Cross-Origin Resource Sharing (CORS) / Import
• Cross-Site Scripting (XSS) / How to secure a web application
• cross site request forgery (CSRF) / Setting up Spring Security

D

• Data Access Object (DAO) / Bean declaration
• Data Definition Language (DDL) / Hibernate
• data modeling
  • about / Introduction to data modeling
  • stages / Data modeling stages and deliverables
  • deliverables / Data modeling stages and deliverables
  • conceptual data modeling / Conceptual data modeling
  • logical data modeling / Logical data modeling
  • physical data modeling / Physical data modeling
• data modeling, goals
  • about / Goals of data modeling
  • completeness / Completeness
  • minimal redundancy / Minimal redundancy
  • extensibility / Extensibility
  • consistency / Consistency
• data modeling, terminologies
  • entities / Terminologies used in data modeling
  • attributes / Attributes
  • relationships / Relationships
  • primary key / Primary keys
  • foreign keys / Foreign keys
• data property / Objects, properties, and property attributes
• data property, attributes
  • value / Objects, properties, and property attributes
  • writable / Objects, properties, and property attributes
  • enumerable / Objects, properties, and property attributes
  • configurable / Objects, properties, and property attributes
• declarative transaction management
  • implementing / Declarative transaction management
• default parameter value / Default parameter value
• DELETE method / Defining operations via HTTP methods
• dependency injection
  • about / Spring IoC and dependency injection
  • implementing / Dependency injection
  • constructor-based injection / Constructor-based injection
  • setter-based/method-based injection / Setter-based/method-based injection
  • field-based injection / Field-based injection
  • best practices / Best practices of dependency injection
• Dependency Inversion Principle (DIP) / The Dependency Inversion Principle (DIP)
• design patterns / Design principles and design patterns
• design principles
  • about / Design principles and design patterns
  • SOLID design principles / SOLID design principles
• design procedure, RESTful API
  • about / RESTful API design procedure
  • requirements, gathering / Finding out the requirements
  • resources, identifying / Identifying resources
  • API details, specifying / Fleshing out API details 
• destructuring assignment
  • about / Destructuring assignment
  • object destructuring / Object destructuring
  • array destructuring / Array destructuring
  • nested destructuring / Nested destructuring
  • rest elements / Rest elements
  • function parameters destructuring / Function parameters destructuring
• development environment
  • setting up / Setting up the development environment
• directives
  • in Vue.js / Directives
• DispatcherServlet
  • creating / DispatcherServlet
• Disqus
  • reference / Declarative transaction management
• distributed denial of service (DDoS) attack / How to secure a web application
• Docker
  • reference / Preparing a Dockerfile
• Domain-Driven Design (DDD) / Hexagonal architecture
• domain model
  • registration, implementing / Implement registration in domain model

E

• E2E tests
  • refactoring / Refactoring E2E tests
  • executing / Running E2E tests during the writing
  • executing, before pushing code to VCS / Running E2E tests before pushing the code to VCS
  • executing, after deploying to staging / Run E2E tests after deploying to staging
• ECMAScript 2015 (ES6)
  • about / ES6 basics
  • let / Block scoping, let, and const
  • const / Block scoping, let, and const
  • block level scope / Block scoping, let, and const
  • classes / Classes
  • enhanced object literals / Enhanced object literals
  • arrow functions / Arrow functions
  • default parameter value / Default parameter value
  • rest parameters / Rest parameters
  • spread syntax / Spread syntax
  • destructuring assignment / Destructuring assignment
  • template literals / Template literals
  • modules / Modules
  • promises / Promises
• EditorConfig
  • reference / File structure
  • about / File structure
• email, sending
  • with Java Mail / Sending emails using JavaMail
  • MailManager, implementing / MailManager and its dependencies
  • dependencies, implementing / MailManager and its dependencies
• end-to-end integration tests
  • performing / Performing end-to-end integration tests
  • port, correcting / Correcting the port
  • Page Objects, using / Using Page Objects
  • user test data, auto-generating / Autogenerating user test data
  • in specific order / Testing in specific order
  • error, fixing / Fixes at the end
• endpoint security, Spring Boot Actuator
  • about / Endpoint security
  • different port, using / Using a different port and firewall
  • firewall, using / Using a different port and firewall
  • same port, using / Using the same port and Spring Security
  • Spring Security, using / Using the same port and Spring Security
  • custom filter, using / Using a custom filter
• enhanced-entity-relationship (EER) diagram / The naming convention
• enhanced object literals / Enhanced object literals
• entities / Entities
• Entity-Relationship (ER) diagrams
  • about / Conceptual data modeling
  • creating / Conceptual data modeling with ER diagrams
  • crow's foot notation / Crow's foot notation
  • naming convention / The naming convention
  • TaskAgile conceptual data models / TaskAgile conceptual data models
  • supertypes / Subtypes and supertypes
  • subtypes / Subtypes and supertypes
• eval code / The this keyword
• Exec Maven Plugin
  • reference / Building with a single command
• executable code
  • about / The this keyword
  • global code / The this keyword
  • eval code / The this keyword
  • function code / The this keyword
• execution flow, Spring AOP / AOP execution flow

F

• Façade design pattern / The Interface Segregation Principle (ISP)
• field-based injection / Field-based injection
• filters
  • in Vue.js / Filters
  • about / Filters
• Flexbox
  • reference / Designing the overall layout
• flickr's web service
  • reference / Level one
• Flow
  • reference / Introduction
  • using / Introduction
• Font Awesome 5
  • reference / Creating wireframes
• Font Awesome Cheatsheet
  • reference / Creating wireframes
• foreign keys / Foreign keys
• FreeMarker / Sending emails using JavaMail, Implementing DefaultMailManager
• frontend, board page
  • building / Building the frontend of the board page
  • UI, creating / The UI of the board page
  • layout, designing / The layout of the board page, Designing the overall layout
  • drag and drop, implementing / Implementing drag and drop
• frontend and backend connection
  • creating / Putting two ends together
  • with build command / Building with a single command
  • communication, bridging / Bridging the communication
• frontend scaffold
  • creating / Creating the frontend scaffold
  • file structure / File structure
  • reorganizing / Cleaning up and reorganizing
  • cleaning up / Cleaning up and reorganizing
  • tests, executing / Didn't we miss something?
• frontend validation
  • implementing / Validation on the frontend
  • data validation, testing / Test the data validation
  • form data, validating with Vuelidate / Validate form data with Vuelidate
• full-stack developer, skillsets
  • about / Full-stack developer skillsets
  • requirement, analyzing / Requirement analyzing
  • communication / Communication
  • wireframes, creating / Wireframes creating
  • data, modeling / Data modeling
  • API, designing / API designing
  • frontend, coding / Frontend coding
  • backend, coding / Backend coding
  • automation tests, writing / Unit tests and automation tests
  • unit tests, writing / Unit tests and automation tests
  • Continuous Integration (CI) / Continuous integration
  • Continuous Delivery (CD) / Continuous integration
  • server, monitoring / Server monitoring and architecture awareness
  • architecture awareness / Server monitoring and architecture awareness
• function code / The this keyword
• function parameters destructuring / Function parameters destructuring
• functions
  • about / Functions and methods
  • invoking / The this keyword

G

• Gang of Four (GoF) design pattern / The Interface Segregation Principle (ISP)
• GET method / Defining operations via HTTP methods
• GitHub Desktop
  • reference / Setting up the development environment
• global code / The this keyword
• GraphicMagick
  • reference / Generating thumbnails for images

H

• Hamcrest / Unit testing of the Messages App
• hexagonal architecture
  • reference / Hexagonal architecture
• Hibernate
  • about / Spring JDBC and JPA
  • using / Hibernate
• Hibernate Query Language (HQL) / Add APIs
• hoisting / Hoisting
• home page backend
  • building / Building the home page backend
  • domain models / Domain models
  • API handlers, using / API handlers
  • application services, creating / Application services
  • repositories, implementing / Repositories and the generic save() method
  • generic save() method, implementing / Repositories and the generic save() method
• home page frontend
  • building / Building home page frontend
  • UI, building / UI of the home page
  • layout / Home page layout and components
  • components / Home page layout and components
  • data, structure / Data structure and state management
  • state management / Data structure and state management
  • backend APIs / Backend APIs
  • implementing / Implementing home page frontend
  • services, implementing / Implementing the services and Vuex store
  • Vuex store, implementing / Implementing the services and Vuex store
  • popup windows, implementing with Bootstrap modal / Implementing popup windows with Bootstrap modal
• hook functions
  • bind / Directives
  • inserted / Directives
  • update / Directives
  • componentUpdated / Directives
  • unbind / Directives
• Hot-Module-Replacement (HMR) / File structure
• http-proxy-middleware library
  • reference / Bridging the communication
• HTTP methods
  • GET method / Defining operations via HTTP methods
  • POST method / Defining operations via HTTP methods
  • PUT method / Defining operations via HTTP methods
  • PATCH method / Defining operations via HTTP methods
  • DELETE method / Defining operations via HTTP methods
• HTTP session / Authenticating users
• HTTP status codes
  • 2xx-Success codes / Use of HTTP status codes
  • 3xx-Redirections / Use of HTTP status codes
  • 4xx-Client error / Use of HTTP status codes
  • 5xx-Server error / Use of HTTP status codes
• Hypermedia As The Engine Of Application State (HATEOAS)
  • determining, for implementation / HATEOAS or not?
  • about / What is HATEOAS?
  • limitations / Why you won't need HATEOAS?

I

• Icinga 2
  • used, for monitoring / Monitoring with Icinga 2
  • about / Monitoring with Icinga 2
  • reference / Monitoring with Icinga 2
• identity provider (IdP) / Single Sign-On
• inheritance / Prototype and inheritance
• Integrated Development Environment (IDE) / Setting up the development environment
• integration test / RESTful API testing
• interface constraints, RESTful API
  • about / RESTful interface constraints
  • resources, identification / Identifications of resources
  • resources, manipulation through representation / Manipulation of resources through representations
  • self-descriptive messages / Self-descriptive messages
  • HATEOAS / Hypermedia as the engine of the application state
• Interface Segregation Principle (ISP) / The Interface Segregation Principle (ISP)
• Inversion of Control (IoC) / Spring IoC and dependency injection

J

• Java-style guide
  • reference / Spin up the Spring container
• Java Database Connectivity (JDBC) / Spring JDBC and JPA
• Java Development Kit (JDK)
  • reference / Setting up the development environment
• Java EE Servlet / Java EE Servlet
• Java Mail
  • email, sending / Sending emails using JavaMail
• Java Persistence API (JPA) / Spring JDBC and JPA
• Java Runtime Environment (JRE) / Setting up the development environment
• JavaScript
  • about / JavaScript from a Java developer's viewpoint
  • functions / Functions and methods
  • methods / Functions and methods
  • objects / Objects and classes, Objects, properties, and property attributes
  • classes / Objects and classes
  • property attributes / Objects, properties, and property attributes
  • properties / Objects, properties, and property attributes
  • prototype / Prototype and inheritance
  • inheritance / Prototype and inheritance
  • scope / Scope and closure
  • closure / Scope and closure
  • this keyword / The this keyword
  • hoisting / Hoisting
• Java Specification Request (JSR)
  • reference / Field-based injection
  • about / Field-based injection
• Java Transaction API (JTA) / Spring transaction management
• Java Virtual Machine (JVM) / Spring JDBC and JPA
• JDBC driver
  • using / JDBC driver
• Jenkins
  • continuous delivery, building / Let's ship it
  • TaskAgile, building / Building with Jenkins
  • reference / Building with Jenkins
• Jenkinsfile
  • reference / Preparing a Jenkinsfile
• Jenkins Pipeline plugin
  • reference / Let's ship it
• Jest
  • using / Introduction
• jjwt library
  • reference / Authenticating a real-time client with JWT
• join points / Join points
• jQuery File Upload
  • reference / Implementing file uploads
• JSONassert / Unit testing of the Messages App
• JsonPath / Unit testing of the Messages App
• JSON Web Tokens (JWT)
  • about / Security
  • real-time client, authenticating / Authenticating a real-time client with JWT
• JSR-250 @RoleAllowed annotation / Method security 
• JUnit / Unit testing of the Messages App

L

• let / Block scoping, let, and const
• Let's Encrypt
  • reference / Installing NGINX and the SSL certificate
• levels, code design
  • architecture level / Architecture level
  • abstraction level / Abstraction level
  • implementation level / Implementation level
• life cycle hooks, Vue instance
  • beforeCreate / Vue instance life cycle
  • created / Vue instance life cycle
  • beforeMount / Vue instance life cycle
  • mounted / Vue instance life cycle
  • beforeUpdate / Vue instance life cycle
  • updated / Vue instance life cycle
  • activated / Vue instance life cycle
  • deactivated / Vue instance life cycle
  • beforeDestroy / Vue instance life cycle
  • destroyed / Vue instance life cycle
  • errorCaptured / Vue instance life cycle
• lift function / Hoisting
• Lightweight Directory Access Protocol (LDAP) / Authenticating users
• Liskov Substitution Principle (LSP) / The Liskov Substitution Principle (LSP)
• Log4j
  • reference / Spin up the Spring container
• logical data modeling / Logical data modeling, Logical data modeling
• login page
  • building / Building the login page
  • UI, implementing / Implementing the login page UI
  • PasswordEncryptorDelegate, implementing / Implementing PasswordEncryptorDelegate
  • authentication, implementing in back-end / Implementing authentication in the backend
  • AuthenticationFilter, implementing / Implementing AuthenticationFilter
  • UserDetailsService, implementing / Implementing UserDetailsService
  • UserDetails, implementing / Implementing UserDetails
  • SecurityConfiguration, updating / Updating SecurityConfiguration

M

• MailManager
  • implementing / MailManager and its dependencies
  • DefaultMailManager, testing / Testing DefaultMailManager
  • DefaultMailManager, implementing / Implementing DefaultMailManager
  • AsyncMailer, implementing / Implementing AsyncMailer
  • application properties / Application properties
• Markdown format
  • about / Implementing support of the Markdown format
  • implementing / Implementing support of the Markdown format
• Maven
  • reference / Spin up the Spring container
• Maven Resources Plugin
  • reference / Building with a single command
• Messages App
  • integration / Put it together
  • code, integrating / Place code together
  • APIs, adding / Add APIs
  • HTTP client, using / HTTP client – axios
  • app.messages package, implementing / Package app.messages
  • unit testing / Unit testing of the Messages App
• methods / Functions and methods
• mini-robots / Maturity and cost
• mixins
  • in Vue.js / Mixins
• Mockito / Unit testing of the Messages App
• modern state management / Modern state management
• modules
  • about / Modules
  • export / Export
  • import / Import
• MongoDB
  • physical data modeling / Physical data modeling for MongoDB
• monitoring
  • with Icinga 2 / Monitoring with Icinga 2
• monitoring plugins
  • reference / Monitoring with Icinga 2
• Monster
  • reference / Introduction
• MVC annotations
  • @RestController annotation / MVC annotations
  • @RequestMapping annotation / MVC annotations
  • @ResponseEntity annotation / MVC annotations
  • @RequestParam annotation / MVC annotations
  • @PathVariable annotation / MVC annotations
  • @RequestBody annotation / MVC annotations
• MyBatis
  • reference / Hibernate, Starters
• MySQL
  • reference / Spring JDBC and JPA
  • installing / Installing MySQL
• MySQL Workbench
  • reference / Physical data modeling

N

• nested destructuring / Nested destructuring
• NGINX
  • installing / Installing NGINX and the SSL certificate
• Nightwatch.js
  • using / Introduction

O

• OAuth 2.0
  • about / OAuth 2.0
  • resource owner / OAuth 2.0
  • resource server / OAuth 2.0
  • authorization server / OAuth 2.0
  • client / OAuth 2.0
• object-relational mapping (ORM) / Spring JDBC and JPA
• object destructuring / Object destructuring
• objects / Objects and classes, Objects, properties, and property attributes
• Open-Closed Principle (OCP) / The Open-Closed Principle (OCP)
• OpenAPI
  • reference / Spring REST Docs
• Open Web Application Security Project (OWASP)
  • reference / Preventing attacks
• opinionated RESTful API
  • about / Opinionated RESTful API
  • Richardson Maturity Model / Richardson Maturity Model
  • HATEOAS / HATEOAS or not?
  • characteristics / Opinionated RESTful API characteristics

P

• P6Spy
  • using / Logging SQL queries and performance tuning
  • reference / Logging SQL queries and performance tuning
• package phase / Building with a single command
• Page Objects / Cleaning up and reorganizing
• PATCH method / Defining operations via HTTP methods
• PayPal's REST API
  • reference / Level three
• physical data modeling
  • about / Physical data modeling
  • for RDBMS / Physical data modeling for RDBMS
  • naming convention / The naming convention
  • for MongoDB / Physical data modeling for MongoDB
• Plain Old Java Object (POJO) / JDBC driver
• PlatformTransactionManager
  • implementing / PlatformTransactionManager
• plugins
  • in Vue.js / Plugins
• pointcut / Pointcuts
• pointcut designator (PCD) / Pointcuts
• popup windows
  • implementing, with Bootstrap modal / Implementing popup windows with Bootstrap modal
• PostCSS
  • reference / File structure
• Postman
  • reference / JDBC driver
• POST method / Defining operations via HTTP methods
• pre-integration-test phase / Building with a single command
• prepare-package phase / Building with a single command
• primary key / Primary keys
• process-resources phase / Building with a single command
• Project Object Model (POM)
  • about / Spin up the Spring container
  • reference / Spin up the Spring container
• promises / Promises
• promises, states
  • pending / Promises
  • fulfilled / Promises
  • rejected / Promises
• properties
  • about / Objects, properties, and property attributes
  • attributes / Objects, properties, and property attributes
  • data property / Objects, properties, and property attributes
  • access property / Objects, properties, and property attributes
• protected resource
  • unauthenticated request / Unauthenticated request on protected resource
• prototype / Prototype and inheritance
• public resource
  • unauthenticated request / Unauthenticated request on public resource
• PUT method / Defining operations via HTTP methods

R

• RabbitMQ
  • reference / Tracking activity asynchronously with AMQP, Installing RabbitMQ
  • installing / Installing RabbitMQ
• Rational Database Management System (RDBMS)
  • about / Physical data modeling
  • physical data modeling / Physical data modeling for RDBMS
• reactive data binding system / Reactivity system
• README.md commit
  • adding / Fixes at the end
• real-time communication
  • implementing, with WebSocket / Implementing real-time updates with WebSocket
• register page
  • UI, implementing / Implement the UI of the register page, Implement the UI
  • layout diagram, creating / Create layout diagram
  • TDD / TDD of the register page
• registration
  • implementing, in domain model / Implement registration in domain model
  • UserService application service, implementing / Implement the UserService application service
  • RegistrationManagement domain service, implementing / Implement RegistrationManagement
  • UserRepository, implementing / Implement UserRepository
• RegistrationApiController class
  • creating / Create RegistrationApiController
  • RegistrationApiControllerTests class, creating / Create RegistrationApiControllerTests
  • implementing / Implement RegistrationApiController and its dependencies
  • dependencies, implementing / Implement RegistrationApiController and its dependencies
• registration form
  • building, with Vue.js / Build registration forms with Vue.js
  • test code, writing / Write test code for the form
  • form bindings, implementing / Implement the form bindings
  • submitting / Handle form submit
  • submitForm() method, testing / Test the submitForm() method
  • submitForm() method, implementing / Implement the submitForm() method
  • communicating, with backend / Communicate with the backend
  • register() method, testing / Test the register() method 
  • register() method, implementing / Implement the register() method
• RegistrationManagement domain service
  • implementing / Implement RegistrationManagement, Implement the RegistrationManagement class
  • RegistrationManagementTests class, creating / Create RegistrationManagementTests
  • dependencies, implementing / Implement RegistrationManagement dependencies
• RegistrationPayload class
  • creating / Creating RegistrationPayload, Create RegistrationPayload
  • RegistrationPayloadTests class, creating / Create RegistrationPayloadTests
• relationships / Relationships
• requirements
  • managing / Managing requirements in an Agile way
  • levels / Levels of requirements
  • business requirements / Levels of requirements
  • user requirements / Levels of requirements
  • functional requirements / Levels of requirements
  • writing, in agile project / Writing a requirement in an Agile project
• resource owner / OAuth 2.0
• RESTful API
  • characteristics / RESTful API characteristics
  • architectural constraints / REST architectural constraints
  • interface constraints / RESTful interface constraints
  • opinionated RESTful API / Opinionated RESTful API
  • design procedure / RESTful API design procedure
  • implementation, in Spring MVC / RESTful API implementation in Spring MVC
  • consuming / RESTful API consuming
  • consuming, with HTTP client / HTTP client
  • server-side consuming / Server-side consuming
  • testing / RESTful API testing
  • Messages App, unit testing / Unit testing of the Messages App
• RESTful API, implementation
  • MVC annotations / MVC annotations
  • Spring HATEOAS / Spring HATEOAS
  • Spring REST Docs / Spring REST Docs
• rest parameters / Rest parameters
• Retry-After header / Use of HTTP status codes
• Richardson Maturity Model
  • about / Richardson Maturity Model
  • Level zero / Level zero
  • Level one / Level one
  • Level two / Level two
  • Level three / Level three

S

• @SecurityCheck annotation
  • creating / @SecurityCheck
• scope / Scope and closure
• scripts / Import
• Security Assertion Markup Language (SAML) / Single Sign-On
• Server Warming Up / Filters
• service provider (SP) / Single Sign-On
• setter-based/method-based injection / Setter-based/method-based injection
• SHA-256 / Implementing PasswordEncryptorDelegate
• Showdown
  • reference / Implementing support of the Markdown format
  • using / Implementing support of the Markdown format
• Simple Mail Transfer Protocol (SMTP) / Sending emails using JavaMail
• Single Page Application (SPA) / State management with Vuex
• Single Responsibility Principle (SRP) / Best practices of dependency injection, The Single Responsibility Principle (SRP)
• Single Sign-On (SSO) / Single Sign-On
• SockJS
  • using / Implementing real-time updates with WebSocket
  • reference / Implementing real-time updates with WebSocket
  • about / Introduction to SockJS
• Software Requirements Specification (SRS) / Levels of requirements
• SOLID design principles
  • about / SOLID design principles
  • Single Responsibility Principle (SRP) / The Single Responsibility Principle (SRP)
  • Open-Closed Principle (OCP) / The Open-Closed Principle (OCP)
  • Liskov Substitution Principle (LSP) / The Liskov Substitution Principle (LSP)
  • Interface Segregation Principle (ISP) / The Interface Segregation Principle (ISP)
  • Dependency Inversion Principle (DIP) / The Dependency Inversion Principle (DIP)
• Sortable.js library
  • reference / Implementing drag and drop
• spread syntax / Spread syntax
• Spring
  • transaction management / Spring transaction management
• Spring AOP
  • about / Spring AOP
  • concerns / Concerns
  • aspects / Aspects
  • join points / Join points
  • advices / Advices
  • pointcuts / Pointcuts
  • proxy / AOP proxy
  • weaving / Weaving
  • @SecurityCheck annotation / @SecurityCheck
  • execution flow / AOP execution flow
• Spring Boot
  • about / Spring Boot
  • reference / Spring Boot
  • starters / Starters
  • autoconfiguration / Autoconfiguration
  • Actuator / Spring Boot Actuator
• Spring Boot 2
  • reference / Declarative transaction management
• Spring Boot Maven Plugin / Building with a single command
• Spring Boot Test / Unit testing of the Messages App
• Spring container
  • signing up / Spin up the Spring container
• Spring HATEOAS
  • about / Spring HATEOAS
  • reference / Spring HATEOAS
• Spring Initializr
  • backend scaffold, creating / Creating the backend scaffold with Spring Initializr
  • reference / Creating the backend scaffold with Spring Initializr
  • file structure / File structure
  • committing / Committing and pushing
  • pushing / Committing and pushing
  • application, executing / Running the application
• Spring IoC
  • about / Spring IoC and dependency injection
  • annotation-based configuration / Annotation-based configuration
• Spring JDBC
  • about / Spring JDBC and JPA
  • JDBC driver, using / JDBC driver
  • using / Spring JDBC
  • Hibernate, using / Hibernate
• Spring MVC
  • about / Spring MVC
  • Java EE Servlet / Java EE Servlet
  • DispatcherServlet / DispatcherServlet
  • views / Views
  • filters / Filters
  • RESTful API, implementation / RESTful API implementation in Spring MVC
• Spring Profile
  • about / Spring Profile
  • dev profile / The dev profile
  • test profile / The test profile
  • end-to-end test profile / The end-to-end test profile
  • production profile / The staging and production profile
  • staging profile / The staging and production profile
• Spring REST Docs
  • using / Spring REST Docs
• Spring Security
  • about / Introducing Spring Security, Spring Security core concepts
  • filters / Spring Security deep dive
  • setting up / Setting up Spring Security
  • filter chain / Spring Security filter chain
  • implementing / Spring Security in action
  • unauthenticated request, on public resource / Unauthenticated request on public resource
  • unauthenticated request, on protected resource / Unauthenticated request on protected resource
  • authentication / Spring Security authentication in depth
  • authorization / Spring Security authorization in depth
• Spring Security Filter Chain / Introducing Spring Security
• Spring Test / Unit testing of the Messages App
• SQL queries
  • logging / Logging SQL queries and performance tuning
• SSL certificate
  • installing / Installing NGINX and the SSL certificate
• state management
  • with Vuex / State management with Vuex, Vuex in a nutshell
  • traditional state management, drawbacks / Drawbacks of traditional state management
  • modern state management / Modern state management
• subtypes / Subtypes and supertypes
• supertypes / Subtypes and supertypes

T

• TaskAgile
  • user stories / TaskAgile user stories
  • wireframes, creating / Creating wireframes
  • code design / TaskAgile code design
  • building, with Jenkins / Building with Jenkins
  • reference / Building with Jenkins
• TaskAgile, shipping
  • Dockerfile, preparing / Preparing a Dockerfile
  • Jenkinsfile, preparing / Preparing a Jenkinsfile
  • server, preparing / Server preparation
  • MySQL, installing / Installing MySQL
  • RabbitMQ, installing / Installing RabbitMQ
  • SSL certificate, installing / Installing NGINX and the SSL certificate
  • NGINX, installing / Installing NGINX and the SSL certificate
• TaskAgile, user stories
  • of Users / Users
  • of Team / Teams
  • of Boards / Boards
  • of Card Lists / Card Lists
  • of Cards / Cards
• TC39 process
  • reference / Modules
• template literals / Template literals
• this keyword / The this keyword
• Thymeleaf
  • reference / Views
  • about / Sending emails using JavaMail
• Tomcat
  • reference / Java EE Servlet
• traditional state management
  • drawbacks / Drawbacks of traditional state management
• transaction management
  • about / Spring transaction management
  • PlatformTransactionManager / PlatformTransactionManager
  • declarative transaction management, implementing / Declarative transaction management

U

• UI
  • building, with Bootstrap 4 / Building a UI with Bootstrap 4
• unauthenticated request
  • on public resource / Unauthenticated request on public resource
  • on protected resource / Unauthenticated request on protected resource
• unit tests
  • of Messages App / Unit testing of the Messages App
  • test profile, adding / Last fix before rolling out
  • debug-level log, turning off / Last fix before rolling out
• Universally Unique Identifier (UUID) / Primary keys
• user authentication
  • about / Authenticating users
  • Single Sign-On (SSO) / Single Sign-On
  • OAuth 2.0 / OAuth 2.0
• UserRepository
  • implementing / Implement UserRepository
  • HibernateUserRepositoryTests class, creating / Create HibernateUserRepositoryTests
  • HibernateUserRepository, implementing / Implement HibernateUserRepository
• User Requirements Document (URD) / Levels of requirements
• users
  • authorizing / Authorizing users
• UserService application service
  • implementing / Implement the UserService application service
  • UserServiceImplTests class, creating / Create UserServiceImplTests
  • UserServiceImpl class, implementing / Implement the UserServiceImpl class
• UserServiceImplTests class
  • creating / Create UserServiceImplTests
  • MailManager interface, creating / Create MailManager
  • domain events, building / Build domain events
• user stories
  • writing / Writing effective user stories
  • tips, for writing / Tips on writing user stories

V

• views / Views
• Visual Studio Code
  • reference / Spin up the Spring container
• VS Code
  • reference / Setting up the development environment
• Vue-I18n
  • I18n support, adding / Adding i18n support with Vue-i18n
  • reference / Adding i18n support with Vue-i18n
• vue-router
  • about / Introducing vue-router
  • reference / Introducing vue-router, Router for board URL and card URL
  • Spring MVC request, mapping / Spring MVC request mapping
• Vue.Draggable
  • reference / Implementing drag and drop
• Vue.js
  • fundamental concepts / Fundamental concepts
  • Vue instance, creating / Vue instance
  • components / Components
  • directives / Directives
  • filters / Filters
  • mixins / Mixins
  • plugins / Plugins
  • reactive data binding system / Reactivity system
  • registration form, building / Build registration forms with Vue.js
• Vue.js 2
  • using / Introduction
• Vuelidate
  • reference / Validation on the frontend
  • installing / Validation on the frontend
  • form data, validating / Validate form data with Vuelidate
  • tests, improving / Improve the tests
• Vuex
  • state management / State management with Vuex
  • about / Vuex in a nutshell

W

• weaving / Weaving
• web application
  • securing / How to secure a web application
  • user authentication / Authenticating users
  • users, authorizing / Authorizing users
  • attacks, preventing / Preventing attacks
• webpack
  • reference / Modules
• WebSocket
  • real-time communication, implementing / Implementing real-time updates with WebSocket
  • about / Introduction to Spring WebSocket
  • implementing / Introduction to Spring WebSocket
  • channel-based communication pattern / The channel-based communication pattern
• WebSocket API
  • reference / Introduction to SockJS

X

• X-Content-Type-Options / Spring Security filter chain
• X-Frame-Options / Spring Security filter chain
• X-XSS-Protection / Spring Security filter chain
• XML External Entities (XXE) / Preventing attacks