This lecture provides a simple definition of Maven, including enumerating some key features.

This lecture describes the reasons the instructor will start with the command-line / terminal with Maven instead of using a graphical client.

An overview of the core concepts that will be covered in this course, including Maven's preference for convention over configuration, the Project Object Model (POM), dependency resolution, Maven repository, lifecycle, and Plugins.

Explaining how dependency resolution works through the chains of dependencies calling on each other, as well as an explanation of how the Maven repository is structured to host your artifacts.

An explanation of the three building blocks of Maven: goals, phases, and lifecycles. And a further explanation of how those work with plugins.

Test concepts learned in the Course Introduction and Core Concepts sections of this course.

An overview of the quick installation that will be done in this section. The required tools are the Java JDK, a decent text editor, Git, and of course Maven.

Installing the software development tool Maven onto our local Windows system.

Installing the software development tool Maven onto our local Mac OS system.

A quick look into how to get help within Maven on our terminal program.

Setting up our project files within our terminal and installing the files we need into the directory from GitHub.

Creating our first maven project from our GitHub repository example code, and running that first project by executing the package goal.

Creating a Hello World Java source code example in the main Java folder in our Maven project in order to have something to execute when running our Maven project.

Executing both the clean and package goals to get our lifecycle going in Maven, in order to review the output in our command to see how Maven builds our project.

Committing our Maven repository's changes to the Git repository we have set up on our local system, making sure to use the ".gitingore" to exclude the target directory.

Downloading an optional helper bash script from GitHub that will set up a skeleton version of a Maven repository using the script.

Creating a standard Java based maven repository by executing the bash script we downloaded in the previous lesson.

Creating the Hello world Java file in the appropriate folder within our Maven project, pasting in the basic hello world Java source code we copied from the GitHub repository.

Updating all of the default values from the Maven POM file in order to add proper Metadata to our Maven project, then re-building our POM to see any changes it created.

Using the "finalname" tag within our Maven POM to rename the final output of our Maven project.

Installing our jar file to our local Maven repository.

Adding and committing our changes from this section to our Git repository, while also adding more unwanted files to our ".gitignore" file.

Setting up our project for this section named words, copying in the contents from our GitHub example repository to replace the automatically created pom, then adding in the Java source code in the expected folder.

Troubleshooting the issues of our project not initially building due to the dependencies not being specified in our Maven POM. We will search for the libraries on Maven Central and then add them to our POM to get it to build.

Committing our changes to our Git repository now that our project has it's needed dependencies.

Reviewing the files Maven generated and placed into the target directory on our local system.

Looking at the local maven repository in the "m2" folder where our final Jar output is placed to explore all of the dependencies that our build is using.

Using Maven's main website to look at all of the Maven dependencies that we are using, then using a command to list out all the plugins we are using in in a specific project.

Compiling our Maven project while targeting a newer version of Java in order to take advantage of newer Java features.

Committing our changes from this section to our Git repository.

Adding unit testing to our "words" Maven project using junit using source code from the GitHub repository.

Running our Unit test results to see what errors come up in order to find and add all of the dependencies needed, before finally compiling our finished unit test program.

Modifying our application test file in order to force a failed build to see what happens when unit tests fail.

Skipping our unit tests in order to still allow a project to create a finalized build without passing the tests.

Disabling unit tests on a permanent basis by configuring our pom to ignore the unit tests we would otherwise run.

Getting a better more human readable version of the Unit tests results by modifying our POM xml by running the maven site phase to generate an HTML report of our unit tests.

Committing our changes from this section to the Git repository on our local system.

Quiz covering dependency management, plugins and unit testing.

A complete guide to installing the integrated development environment Eclipse to your local Windows system.

Configuring your installation of Eclipse in order to work with our installation of Maven on our system.

Adjusting our settings on Mac OS X in order to allow applications from anywhere to be installed onto our local Mac system.

A complete guide to installing the integrated development environment Eclipse to your local Mac OS system.

Creating our first new maven project within Eclipse, letting the IDE handle the busy work of creating all the needed files and folders.

Creating our first Java class within the Eclipse IDE, making a basic hello world example output before finally running that output.

Importing an existing Maven project we have already created into our Eclipse IDE, choosing which goals will be run when we run the project within Eclipse.

Using eclipse to modify the POM XML file with a graphical interface.

Using Maven archetypes to jump start a newly created Maven application.