Abstract data types

Abstract Factory Pattern

Abstraction

Accounting tools

Adapter pattern

Agile methodology

Akka toolkit

Algebraic data types

Alternatives to Spring and spring boot

Analysis of Algorithms

Angular

Apache Camel

Apache Commons libraries

Apache Wicket

API Gateway pattern

API Keys

API Versioning

Applying for a job in Silicon Valley companies

Are domain model and data model the same?

Artificial intelligence (AI) and machine learning (ML)

Asymmetric encryption

Asynchronous calls in Spring applications

Asynchronous programming

Authentication vs Authorization

Autoboxing

Automatic Batching

Avoid if-else statements using collections

awk

AWS - Connecting from java applications

AWS - Creating IAM users for programming

AWS Architecture

AWS CLI

AWS Cloud Development Kit (CDK)

AWS CloudFormation

AWS CloudWatch

AWS DynamoDB

AWS ECS

AWS Gateway

AWS Lambda

AWS Route53

AWS S3

AWS S3 - Uploading InputStream to AWS S3 using Multipart Upload

AWS Serverless Application Model (AWS SAM)

Axios proxy issues

Azure Architecture

Azure Compute and Networking services

Azure Cost Management

Azure Governance and Compliance

Azure Identity, Access and Security

Azure Monitoring Tools

Azure Storage

Azure Tools for Managing and Deploying Resources

Bad programming practices

Bags (Abstract Data Type)

Base64 encoding and decoding

Basic steps for setting up a NodeJS application

Big Data Processing Frameworks

Big O notation

Binary Search Trees

Binary Trees

Bitwise operations

Bitwise operations and Logical operations using XOR

bootstrap toolkit

Bridge pattern

Browser extensions for Web Development

Browsers

Bubble Sort

Bucket Sort

Build tools

Builder pattern

Caching

Caching in Hibernate

Calibre book-reader customization

Callable and Runnable

Can you cheat recruitment process by practicing Algorithmic Puzzles?

CAP theorem (consistency, availability and partition tolerance)

Cascading Style Sheets (CSS)

Centralized Systems

certbot

Chain of responsibility pattern

Characters, Character Sets and Encodings

Chrome browser

Circuit Breaker pattern

Cloud computing

Cloud computing - Benefits

Cloud computing - security

Cloud Design Patterns

Cloud Design Patterns - Saga distributed transactions pattern

Cloud Design Patterns - Transactional outbox pattern

Cloud Service Types - XaaS (anything as a service)

Cloud storage options

Cluster

Cntlm

Code aesthetics

Cognitive and Cyclomatic complexity

Collections

Collections - ArrayList

Collections - Arraylist vs Arrays

Collections - ArrayList vs Vector

Collections - Arrays

Collections - Comparing two lists

Collections - Helpful utility libraries

Collections - Infinite Lists

Collections - Iterable collections and Iterators

Collections - Iterators and Enumeration

Collections - Java List interface

Collections - Linked List vs Arrays and ArrayLists

Collections - Linked lists

Collections - Map interface

Collections - Reconcile objects in two collections

Collections - Set interface

Collections - Sorting ArrayList of user-defined objects

Collections - Synchronized collections

Collections - Vector

Collections - Vectors vs Arrays

Command pattern

Command Query Responsibility Segregation (CQRS)

Command to put computer to sleep

Commands to run tests on individual files

Comparator interface vs Comparable interface

Comparison between Queues and Topics (SQS and SNS)

Compile from source

Compiled, Interpreted and Hybrid (Portable Compiled) Programming Languages

Compilers and LLVM

CompletableFuture Async methods

Composite pattern

Compress Response Payloads

Computer Networking and Cyber Security

Computer Science

Computing process, Thread and Scheduler

Concurrency

Concurrency Control

ConcurrentModificationException

Containerization

Content Delivery Network

Context API

Contexts and Dependency Injection (CDI)

Continuous integration and continuous delivery (CI/CD or CICD)

Contract first approach to API development

Convention Over Configuration

Converting html apps to React apps

Copying files and directories

Core J2EE Patterns

CORS

Counting Sort

cp command

Creating a React application

cron schedules

Cross Site Scripting attacks - XSS

Curl

Custom React hooks

Cutting Cloud Run costs with Caching and Data Optimization

Cygwin

Daemon Threads

Dao pattern

Data Engineering

Data Engineering vs Data Science

Data modeling

Data Science

Data Structures

Data types

Database Normalization

Database Optimizations in Java applications

Databases

Databases - GUI clients

Declarative Programming

Decorator pattern

Definition of done

Deleting files and folders

Depend upon abstractions - Program to an interface

Dependency hell

Dependency Injection pattern

Design patterns

Design principles

Design tools

Deterministic Simulation Testing

Difference between Design patterns and Design principles

Different types of locks in Java

Different ways of loading data into databases at spring application start-up?

Disaster recovery

Display Auto-Configuration Report in Spring Boot

Distributed Coordination

Distributed locking

Distributed Systems

Distributed tracing and Observability

distroless

ditaa

Divide, Conquer and Combine paradigm

DNS Leaks

Docker

Dockerfile and Docker compose

Dojo Toolkit

DOM

Domain Name System

Drawing flow diagrams and UML diagrams

Dynamic Method Dispatch or Late Binding or Runtime Polymorphism in Java

Dynamic Programming

ebook software

Eclipse

Edge Computing

EditorConfig

Elasticsearch

Elasticsearch - How to set-up configuration in a springboot application when ssl is enabled for elasticsearch

Elasticsearch - Java API Client vs Spring Data Elasticsearch

Elasticsearch - Spring Data Elasticsearch compatibility matrix

Elasticsearch - starting in a docker container

Elasticsearch - Tracing requests

Elasticsearch and OpenSearch

emacs

emacs - auto completion

emacs - buffers, tabs, splits, windows and frames

emacs - Change fonts

emacs - Comments

emacs - comparing files

emacs - configurations for reference

emacs - deleting

emacs - dired

emacs - environment variables

emacs - evaluating expressions

emacs - eww

emacs - exporting org documents to Word

emacs - file navigation

emacs - functions

emacs - games

emacs - help system

emacs - Inserting timestamps in files

emacs - installation and configuration

emacs - Launching

emacs - line numbers

emacs - lists

emacs - macros

emacs - mark and region

emacs - modes

emacs - movement within a file

emacs - org agenda notes

emacs - org mode notes

emacs - org-roam

emacs - org-timer

emacs - Rename something in an entire project

emacs - renaming files

emacs - renaming files using dired

emacs - search and replace

emacs - spelling

emacs - system type

emacs - tables

emacs - terminal

emacs - text manipulation

emacs - the point

emacs - working with lines

Encapsulate what varies

Encapsulation

Enterprise Search Engines

Enterprise Search Engines - Aggregations

Enterprise Search Engines - helpful queries and commands

Enterprise Search Engines Java Clients

Environment variables

Error handling

Event driven architecture

Event driven architecture - Event

Event Sourcing pattern

Events and Event Handling

Evolutionary Database Design and Database automigrations

Example scenarios where a senior software engineer has to analyze huge amounts of data to solve problems

Executor framework

Express Web Framework for Nodejs

Externalized configuration pattern

Facade pattern

Factory Method pattern

Factory patterns

Fat Jar or Uber Jar and Shading dependencies

Favor composition over inheritance

Federated Identity

File and Folder comparison tools

final-finalize-finally

Firefox browser

Flyweight pattern

For loops vs map-filter vs List Comprehensions

Formdata in OpenAPI specification file

Forms of Dependency Injection

Framework vs Library

Front end development

Frustrations with spring framework

Function Composition or Object Composition

Functional Interfaces - Java pre-defined functional interfaces

Functional Interfaces, Lambda Expressions and Method References

Functional Programming

Functional vs Object-Oriented Programming: Fundamental Differences

Gang of four design patterns

General Rules of React Hooks

General tips for solving coding challenges

Generate server and client code from OpenAPI specification file

Generics

Git

Git - Authentication issues

Git - cherry picking

Git - commit messages

Git - Configure tooling

Git - Cutting releases from commits

Git - Diff And Merge - Settings and Tools

Git - Helpful scripts

Git - installation

Git - local workflow when working with codebases and branches

Git - logs

Git - Migrating code and history from one repository to another

Git - Moving around

Git - precommit and prepush hooks

Git - Pull, Merge and Rebase

Git - Push

Git - Remove old commit information from a git repository to save space

Git - Removing sensitive information

Git - reversing changes

Git - Squashing commits using commands

Git - Staging area, adding and removing commits

Git - stashing

Git - working with branches

Git - Working with forks

Git - working with tags

GitHub Actions

GoLang - Formatting and Styling

GoLang - Managing Dependencies

Golang - marshalling, encoding, sending responses to client applications

Golang - Sort struct fields in alphabetical order

GoLang - Working with databases

GoLang Installation

GoLang Modules

GoLang notes

GoLang Testing

GoLang Web frameworks

GoogleAppEngine

GPG keys

Gradle

Gradle - Multi-Project Builds

Greatest Common Divisor (GCD)

grep

gRPC

Hard truths before switching to Go

Haskell - installation

Haskell - notes

Heap (data structure)

Heap Sort

Height and Depth of Binary Tree

Hibernate

Horizontal Scaling

Hosting platforms

Hosts file

How are Threads allocated to handle Servlet request

How can learning front-end tech like React or Angular help a backend engineer?

How databases store passwords securely

How do I find out the class for an application to assign it to a workspace in i3?

How does a compiler break down code into assembly language? With a simple program, what does this look like?

How does a VPN work?

How often do tech companies ask LeetCode Hard questions during interviews?

How Passkeys Work - and How to Use Them

How should I prepare for the Amazon online coding interview?

How to convert HEIC photos to something normal?

How to Crack Your Next Software Developer Job Interview: An Actionable Guide

How to disable selection options using JavaScript?

How to force a public Wi-Fi network login page to open?

How to formulaically solve tree challenges?

How to interview engineers?

How to start a springboot application in debug mode?

How to validate Json files?

How to write Thread-Safe Code in Java

html and css

HTML and DHTML

HttpServletRequest, HttpServletResponse and HttpSession

HttpServletRequestWrapper

Hugo themes and customizations

Icon libraries

ics files - calendar management

IDE extensions for Web Development

Idempotence or Idempodent operation

Image tools

Imperative Programming

Imperative programming vs Reactive Programming

In Windows, can I make the right-click context menu always be in the "show more options" mode by default?

Inbound Outbound models in programming

Infrastructure as a Service (IaaS)

Infrastructure as Code (IaC) tools

Inheritance

Inheritance - Diamond problem

Initial Render and Re-Renders

Insertion Sort

Installing and Using Homebrew

Installing different products from Jetbrains

Integrated Development Environment (IDEs) and Text Editors

IntelliJ

IntelliJ - Reformatting code before you commit it

Interfaces and Abstract classes

Inversion of Control

IOC Containers

Is Intellij IDEA Ultimate is worth the price?

Iterator pattern

Jackson ObjectMapper

Java - default methods in Interfaces

Java - solving the diamond problem with default methods in interfaces

Java - static methods in Interfaces

Java 8 Concurrency API improvements

Java CountDownLatch

Java distributed locks

Java FencedLock

Java Future vs CompletableFuture

Java installation

Java IO

Java IO - Reading lines using BufferedReader and Scanner

Java IO - Read file from resources folder reliably in Spring Boot

Java Management Extensions (JMX) and JConsole

Java Mapping Frameworks

Java notes

Java object equality

Java Optional Class

Java Process API

Java ReadWriteLock

Java Reflection

Java SerialVersionUID: Object Versioning

Java Streams Api

Java Streams Api - Aggregate operations

Java Streams Api - Custom Collectors

Java Streams Api - Difference Between Map and flatMap

Java Streams Api - Operations

Java Streams Api - Parallel programming

Java Streams Api - Pipelining

Java String Pool / String literal pool / String interning

Java StringBuilder and StringBuffer

Java Threads

Java Threads - Creating, Starting and Running them

Java Threads - How to kill them?

Java try with resources enhancements

java versions

Java vs C++

java8

java8 - Date-Time package

java9

Javascript - fetch requests with Bearer tokens

Javascript and Typescript notes

JavaScript Template Literals

JDBC

Jest testing tips

JPA - Avoiding the N+1 Problem

JPA - Composite Primary Keys

JPA - entity associations and association mappings

JPA - Entity Object Life Cycle

JPA - Inheritance strategies

JPA - Jakarta Persistence API

JPA - Jakarta Persistence Query Language - JPQL

JPA - JOIN FETCH

JPA - native queries

JPA - Persistence, EntityManagerFactory, EntityManager and PersistenceContext

JPA - Providers

JPA - Repository pattern

JPA Buddy

JSPs

JSX

JSX - CSS

JSX - if else condition

JSX - Javascript

JUnit testing

JUnit testing - check for exceptions

JUnit testing - ExtendWith

Kafka

Kafka - CLI and GUI tools

Kafka - Clusters, Controllers and Brokers

Kafka - Consumers and Consumer Groups

Kafka - Delivery semantics

Kafka - Fan in and Fan out

Kafka - fault tolerance

Kafka - How are brokers, topics and partitions related

Kafka - Idempotent Producers and Consumers

Kafka - Integration testing

Kafka - Messages

Kafka - PartitionReassignment

Kafka - Producers

Kafka - replication

Kafka - security

Kafka - Serialization and Deserialization

Kafka - Stream Bridge

Kafka - Topics, Partitions and Offsets

Kafka - Transactions

kafka and zookeeper

Key Differences and Overlaps between SSH keys and GPG keys

Keyrings

Killing a CPU process

Knowledge gaps and ideas for Proof of concepts

Kubernetes

Large Scale System Design and Architecture

Least Common Multiple (LCM)

Lenovo Thinkpad tips

Linux

Linux - Changing permissions on files and folders

Linux - Comparison of Linux and Windows in terms of system architecture

Linux - Debugging ENOSPCSystemLimitForNumberOfFileWatchersReached

Linux - Desktop environments

Linux - Display Managers

Linux - Distributions

Linux - Essential concepts

Linux - File I/O operations from terminal

Linux - Helpful commands

Linux - Init systems

Linux - Issues running App Images

Linux - packages and package managers

Linux - PKGBUILD contains CRLF characters and cannot be sourced

Linux - Restoring UI panels in a desktop environment

Linux - screen lockers

Linux - System information

Linux - System Monitors

Linux - System Report

Linux - Trying To Get The Keyboard To Work With Linux

Linux - Understanding the file system

Linux - Window Managers

Linux - Windowing System

Linux - WSL

Listing Directories and Files in a folder

LiteIDE

LLVMs

Load balancer

Localstack

Locking Mechanisms in Java

Logarithms and Exponentials

Lost Update in Database Systems

macOS - creating folder in the root

macOS - Keyboard Shortcuts

macOS - Security Tools

macOS - Terminal shortcuts

macOS - Uninstalling Applications

Makefiles

Managing bookmarks in browsers

Managing certificates in Java_Home and Websphere_Application_Server

Managing entity associations, relationships and updates in applications

Master-Workers Architecture and Leader Election Algorithm

Maven

Maven - archetypes

Maven - commands

Maven - dependency updates

Maven - dependencyManagement vs dependencies

Maven - Enforcer

Maven - errors

Maven - generate maven settings.xml in an enterprise environment

Maven - Installation details

Maven - Jacoco Configuration

Maven - Java Check-style and Formatting

Maven - Managing Dependencies with AWS SDK for Java

Maven - managing spring, springboot, starter parent versions in a multi module project

Maven - maven-compiler-plugin

Maven - Multi-Module Projects

Maven - profiles

Maven - Recursively update pom version in a multi-module project

Maven - release plugin

Maven - Toolchains

Maven - Understanding dependencies used by a project

Maven - Using custom jvm-config

Maven - using openrewrite for version upgrades

Maven - working with sudo or working with different versions

Maven vs Gradle

Maximizing Concurrency while making RESTful calls from a client in Java

Maximum Subarray Problem

Media players and editing

Mediator pattern

Memory Allocation and Garbage Collections

Memory Disk running out of memory

Memory management

Merge Sort

Message Queues

Microservices architecture pattern

Migrating from Maven to Gradle

Mockito

Momento pattern

MongoDB

Monitor

Moral lessons from free software and GNU Emacs

Mouse issues in Windows

Multi threading and Concurrency

Multiple workspaces

My notes about Phones and Android

Native Executables

Netbeans

Next.js for static websites

Nextcloud

Nextcloud - auto upload photos and videos from phone

Nextcloud - inexpensive hosting

Nextcloud - Installation and set-up guides

Nextcloud - Security

Nextcloud - use cases

NextJS

Ninja build tool

No Silver Bullets

Node

Non-blocking IO

npm and yarn

npm and yarn - see code coverage on entire project

Numeral Systems

NumPy: Supercharging Python for Scientific and Numerical Computing

OAuth 2.0

OAuth Grant Types and Flows

Object-Oriented Programming

Observer pattern

OIDC: Secure Authentication with OpenID Connect

Open source projects

OpenAPI

OpenSearch

OpenVPN vs. WireGuard

Optimistic locking vs pessimistic record locking

org-mode + org-roam + Hugo + GitLabs

org-mode + org-roam + Hugo + Hugo themes + github/gitlab

org-mode + org-roam + quartz + gitlab/github

ORM

Overriding vs Overloading in Java

PageFind

Parsing Grammer Expressions and Specifications

Pass by value and Pass by reference

Path

Pathfinding Algorithms

Pdf tools

Performance Engineering

Performance Optimizations

Permutations

plantuml

Podman

Pointers

Policy Language

Polymorphism

Postman

Problem reports

Procedural Programming

Process improvements

Producer Consumer design pattern

Profiling

Programming - how to get better at it

Programming Languages

Programming Languages - Speed of development and Speed of execution

Programming Paradigms

Project Lombok

Prototype pattern

Providing centralized, runtime configuration using Plugins

Proxies in Spring

Proxy pattern

Pull requests and Code reviews

Putty

Python and C++

Python notes

Python Testing

Quantum Computing

Queues (Abstract Data Type)

Quick Sort

Quick sort vs Merge sort

Race condition

Radix Sort

React

React - Gotcha with setstate Function

React Components

React Development tips

React Events

Reactive Programming

Reactive Programming - Challenges

Reactive Programming - Convert REST endpoints to be Reactive

Reactive Programming - example use cases

Reactive Programming - Implementations of the specification in Java

Reactive Programming - Operators

Reactive Programming - Project Reactor

Reactive Programming - Project Reactor - Flux

Reactive Programming - Project Reactor - Mono

Reactive Programming - Project Reactor - Sinks.Many

Reactive Programming - Reactive Manifesto - Reactive programming specification

Reactive Programming - Schedulers

Reactive Programming - Terminology

ReadyAPI

Recursion

Red Hat Openshift

Redis

Referential Transparency

Regex pattern to filter named space XMLs using MdcPatternConverter

Regular Expressions (regex)

Renaming files and directories

Request Logging

Resource Acquisition Is Initialization Pattern

Resources to learn React

Reverse proxy server

Reverse proxy server - Apache

Robocopy

rsync

Running jar files from terminal

Rust - Boxing and Unboxing

Rust - cargo commands

Rust - creating a project

Rust - Embracing Functional Programming Patterns

Rust - notes

Rust - Standard IO

Rust - Standard library and crates

Rust - Traits

Rust - why learn the language

SAML

Scripts to do something on multiple applications

Search a Git repository by commit message or Search the actual content of commits through a repo's history

Search engines

Search for files, file contents and text manipulation

Searching algorithms

Security, Authentication, Authorization and SSL

Selection Sort

Semaphores in Java

Serialization and Deserialization in Java

Serialization Optimizations in Java applications

Serverless Computing

Serverless Framework

Service registration and discovery

Servlet and ServletContainer

Set-up for Haskell literate programming in emacs

Set-up linter and prettier for a React application

Shared Responsibility Model

Shell

Shell Sort

Short Circuit Evaluation

Should I use react-router-dom or react-router?

Side effects

Sidecar pattern

Single page applications (SPAs) and Micro Frontends

Singleton pattern

Singleton pattern - arguments against it

Singleton pattern - breaking Singleton

Software as a Service (SaaS)

Software Engineering

Some cool programs every programmer should make atLeast once

SonarQube

Sorting algorithms

Special characters in proxies

Spock

Spring - Application Events

Spring - CommandLineRunner interface

Spring - Concurrency Model

Spring - design patterns used

Spring - DispatcherServlet

Spring - Events

Spring - exception handling

Spring - Externalized Configuration

Spring - REST API design and implementation

Spring - Running an app with Springboot vs standard Spring framework

Spring annotations

Spring Aspect Oriented Programming

Spring auto configuration

Spring auto configuration - Conditional

Spring batch

Spring Bean Factory

Spring Beans

Spring Beans - Autowiring

Spring Beans - Lifecycle

Spring Beans - Scopes

Spring Boot - Embedded servlet containers

Spring Boot actuator

Spring Boot application without main method

Spring Boot application without web component

Spring Boot Devtools - Automatic Reload

Spring Boot file IO

Spring Boot good practices

Spring Boot starter parents

Spring Boot startup behavior

Spring Boot Testing

Spring Boot Testing - Integration tests for the Controller

Spring Boot Testing - MockMvc

Spring Boot Testing - Using ReflectionTestUtils for Unit Testing

Spring Boot Testing - WebMvcTest

Spring Cloud and Cloud native development

Spring Cloud AWS

Spring Cloud Function

Spring Cloud Gateway

Spring Cloud Stream

Spring Cloud Stream - A business scenario use case

Spring Cloud Stream - Binders, Bindings and Binding names

Spring Cloud Stream - interfaces for Producing and Consuming Messages

Spring Cloud Stream - Testing

Spring Data

Spring Data - Repository populators

Spring Data Elasticsearch

Spring Data JPA

Spring Data JPA - Batch entity inserts and updates

Spring Data JPA - Dynamic Queries with SpEL Expressions

Spring Data JPA - Entities

Spring Data JPA - Generated Queries

Spring Data JPA - Pagination

Spring Data JPA - Pagination and Sorting

Spring Data JPA - Queries

Spring Data JPA - Reasons to use

Spring Data JPA - Repositories

Spring Data JPA - setup and configuration

Spring Data JPA - Single entity inserts and updates

Spring Data JPA - testing

Spring Data JPA - transactions

Spring Data JPA - Using Projections for Selective Data Retrieval

Spring Data JPA - working with multiple databases

Spring Data R2DBC

Spring framework

Spring Interceptors vs Servlet Filters

Spring IOC Container

Spring modules

Spring MVC

Spring MVC - Accessing HttpRequest from controller

Spring profiles

Spring RestTemplate

Spring security

Spring security - Architecture

Spring security - Configuring an application to use spring security

Spring security - How to setup Basic Authentication in Spring WebClient while invoking external APIs

Spring security - required dependencies to use spring security

Spring security - Using Spring OAuth2 RestTemplate

Spring WebFlux

Spring WebFlux - retry logic

spring-boot-maven-plugin

SQL Constraints

SQL Cursors

SQL injection

SQL Nolock

SQL queries

SQL Stored Procedures

SQL Views

SQL vs NoSQL

SQS retries

SSH keys

Stable Sorting

Stacks (Abstract Data Type)

State pattern

static keyword

Static vs Dynamic Programming Languages

Steps for building content folder from org files using org-roam

Stopping spam calls

Strategy pattern

Stream Processing Systems

Stream Processing with Apache Kafka

Stream Processing with RabbitMQ

Streaming

Streaming vs Messaging

String class and char

Strive for loosely coupled designs between objects that interact

Structure of React projects

Supplier

Switching from using Elasticsearch to OpenSearch

Synchronized keyword

systemd

TCP and TCP Handshake

Template method pattern

Terraform

Testing

Testing React applications

The 2 types of software engineering interviews and how to prepare for them

The Case Against JavaScript

The Dependency Inversion Principle

The Law of Leaky Abstractions

The only 6 types of questions you need to know to ace any coding interview

The Open-Closed design principle

The Principle of Least Knowledge

The Simple Factory Idiom

The SOLID design principles

The Stack and the Heap

Thread safety

Thread synchronization

tmux

Tomcat server

Toolbox

Topics and questions for coding challenges

Trees (Abstract data type)

tsh - Trusted Shell

Typing skills

Understanding Google OAuth

Understanding ID Token

Understanding programming

Understanding reactor-kafka

Understanding SSL

Understanding the password anti-pattern

unzip

useEffect hook

useReducer hook

useRef hook

useState hook

Using fast and slow pointers at once

Using ox-hugo

Using props in React

Using sdkman to install and manage jdk versions

Using switch control structure

View Directories and Files in a Tree Structure

Vifm

vim

vim - buffers, tabs, splits and windows

vim - completion

vim - deleting

vim - ex commands

vim - file comparison

vim - help system

vim - installation and configuration

vim - java development

vim - line numbers

vim - lists

vim - macros

vim - marks and motions

vim - movement within a file

vim - netrw

vim - Plugin Fugitive

vim - Plugin fzf

vim - sample vimrc configurations for reference

vim - search

vim - spelling

vim - tags

vim - terminal

vim - text manipulation

vim - thoughts on spacevim

vim - vim and git

Virtualization

Visitor pattern

Visual Studio Code

VPN set-up

Vulnerabilities

Web developer

Webpack

Website publishing - tools and options

Websites and other Resources to prepare for coding challenges

Websphere Integration Developer

What a Software engineer should know?

What are some ways to maximize concurrency in Java?

What are the different ways to write clients for RESTful calls in java applications?

What are the pitfalls of using springboot for java applications?

What does it take to crack Google's interview?

What happens when you type a URL into your browser?

What is a CompletableFuture?

What is ca.pem?

What is server-chain.pem?

What is server-key.pem?

What is the best way to prepare for Google interview in 3 months?

What is the difference between Inheritance and Polymorphism?

What is the difference between UDP and TCP?

What questions were you asked in the programming interview for Google, Amazon, Facebook, or Microsoft?

Who has the key in End-to-End Encryption?

Why do I need to know how to code on paper if it is only useful during an interview?

Why is String immutable or final in Java?

Why is there a huge difference between algorithm questions in a technical interview and the actual software development?

Why learn React?

Wizdler

Wordle Coding Exercise

Working with flash drives

Working with json objects and json files

Working with multiple JDK versions

XOR Linked Lists

You Might Not Need an Effect

Zero Cost Abstractions

Zipping folders

Zookeeper

Zookeeper - Debugging applications

Zookeeper - Watchers, Triggers and Failure Detection

Zookeeper Client Threading Model

Zookeeper Installation, Configuration and Tooling

Zookeeper Java API

Zookeeper Locks