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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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
- 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