Skip to content

Latest commit

 

History

History
64 lines (52 loc) · 3.72 KB

Learned.md

File metadata and controls

64 lines (52 loc) · 3.72 KB
Raw

What have I learned through this project?

JavaFX Custom Components

  • Understanding how to create CC's with this video as a guide.
  • Experimenting with CC's to figure out how to correctly turn them into jar files that are compatible with SceneBuilder, thus making them easier to work with in front-end design.
  • Utilizing CSS to style components and make them look like the puzzles in the game.

Project Tech/Design Choices

When my friend was working on the project, he helped me decide to move to a RadioButton design for switching between puzzle displays. This helped me get away from my previous design of nested TabPanes in a TabPane, which probably isn't the most visually appealing.

Another thing we talked about while he was on the project was moving back to Java 8 since it was easier to work with JavaFX. This decision was later reversed after some time experimenting in Gradle.

Gradle/Continuous Integration

  • Using the build.gradle file to organize dependencies and plugins, facilitate testing, set up distributions in zip and tar files, and releases for GitHub.
  • Making custom tasks and using parameters for CI pipelines to partition my test suite.
  • Automating tests with CircleCI using this video as a guide to get the initial set up.
  • Partitioning my test suite to understand how test splitting and YML file syntax worked and how to parse Circle CI documentation
  • Coming across LGTM (when it was still around) Codacy and taking advantage of its code quality checking for flaws in my Java code.

Graphs and their Algorithms

  • Understanding how graphs work by watching videos on the theory, creating them from scratch and using the JGraphT library to solve different puzzles.
  • Making use of Dijkstra's Shortest Path and A* to solve different problems.

From my first internship

  • Using a backlog to organize tasks that are done, in progress, or haven't been looked at.
  • Creating results that get deployed to GitHub and can be downloaded by anyone.
  • Using a less technical version of design documents. I used them to outline how I will solve puzzles and what the front end will look like.

From my Classes

School

Tools & Practices

  • Understanding how to use Git and GitHub to host my project when analyzing the needs of my project.
  • Having an introduction to Gradle from one of my teammates trying to bring it into our school project. (Wasn't successful, but still, it was a discovery)

Verification

  • Understanding the perks of TestNG vs. my previous experience with J-Unit as it relates to how the project could benefit.
  • Discovering Pitest, Exploratory Testing, Mockito, and Jacoco as different ways to test code and thinking about which concepts I should implement into the project.

Design Patterns

  • Using Strategies, Factories, Facades, and Observers to facilitate repeated code and updating related modules.
  • Being introduced to code coupling and cohesion, which was later applied when I had a CodeMR free trial.

Udemy

  • Understanding how to write Groovy code. Link
  • Using CompletableFuture to split up unrelated tasks, especially for the program boot up process. Link
  • Utilizing functional interfaces and the Streams API wherever necessary. Link
  • Learning about graph algorithms and heuristics. Link