@aaryan_s

Day 14 – Terminal Readability / Debugging (Continuation of Day 13)

· Made average/min/max display N/A when there are no successful tests
o Improved failed-test output so failed pings don’t misleadingly show 0 ms

· Fixed the test-number display (TEST 1 OF 2, TEST 2 OF 2)
· Fixed the duplicate results caused by nested loops (loop within another loop)
· Tested failed hostnames and verified that it results in a 100% packet loss
· Kept debugging messages temporarily
· Deferred method refactoring for later

Day 13 – Readability / Displaying Clean Info on User Terminal

· Improved the readability of individual ping results by labeling each test (TEST 1 OF 2, TEST 2 OF 2, etc.)

o Fixed the successful-test counter so successful tests are counted correctly

· Fixed the duplicate test display caused by accidentally using nested loops (loop inside of another loop)

·  Added the foundation for minimum and maximum latency calculations

·  Added success/failure, total latency, + min/max latency analysis into stored results analysis section

·  Fixed a variable declaration issue with totalLatency and successfulLatencyTests (order matters in code)

·  Overall: Day 13 focused on making the output cleaner and turning the stored ping data into more useful statistics

Day 12 – Formatting and Proper Displaying of Data – 8/31/26

· Added packet-loss formatting using printf to display percentages to 2 decimal places.

o Improved the final ping-test summary for readability.

· Verified the program correctly calculates and displays:
o Successful tests
o Failed tests
o Packet loss
o Average latency

· Debugged an issue where the old println formatting was still being used.

· Learned how Java printf formatting works, including %.2f, %%, and %n.

· Chose to postpone additional rounding/refinement work until later if needed.

· Day 12 milestone: The analyzer can now perform multiple ping tests, store the results, analyze them, and presents the key network statistics in a clean summary to the user.

Day 11 – Analyzing Multiple Ping Tests (Collecting Data)

· Added successful and failed test tracking using PingResult.success.
o Calculated the number of successful tests and failed tests.

· Added packet loss calculation:
o Failed Tests ÷ Total Tests × 100

· Implemented average latency
calculation using ONLY successful tests
o Failed tests do not measure any latency, so do not include within calculation

· Fixed the average latency calculation by properly incrementing successfulLatencyTests.

· Verified that multiple ping results are correctly stored in the ArrayList.

· Added a final PING TEST SUMMARY
displaying:
o Successful Tests
o Failed Tests
o Packet Loss
o Average Latency

· Tested the program with 3 pings to Google, successfully producing:
o 3 successful tests
o 0 failed tests
o 0% packet loss
o ~11.67 ms average latency

Day 10 - Multiple Ping Tests & Result Storage

• Implemented an ArrayList to store results from multiple ping tests.

• Added user input for the number
  of ping tests to run

• Added input validation to ensure the number of tests
  is a valid positive whole number

• Created a for loop to automatically run the requested
  number of ping tests

• Stored each PingResult in the ArrayList after every
  successful test.

• Added a results counter using results.size() to verify
  that results are being stored correctly.

• Confirmed the program successfully ran 3 separate tests to Google and stored all 3 results

• Debugged the output and identified/removing the unnecessary extra ping test result

• Verified latency extraction, success/failure detection, and timestamp functionality alongside  new multi-test Ping system for my code

Key milestone: The analyzer can now run multiple

Day 9 – Heavy debugging and Two-Step Verification

· Debugged and refined the program’s user-input and control-flow systems.

o Implemented a two-step verification process using if / else if / else logic to confirm intended program usage
before proceeding.

· Improved the survey consent workflow, allowing users to decline the survey while still accessing the Wi-Fi Latency Analyzer.

· Debugged several issues involving conditional statements, loops, and program termination

o Including changing Scanner object name to Input (more consistent and widely accepted)

· Improved timestamp readability

o Replacing Java’s default timestamp format with a user-friendly date/time format

o Continued testing the analyzer with real network connection

o Verified that latency measurements and timestamps were being returned correctly.

· Edited/added more relevant comments

Day 8 – Debugging and Data Collection
(beta version)

·    Debugged and improved the control flow
(survey ProcessBuilder, pingResult… etc.)

o   Fixed “if else” function displaying semi-colon

o   Added safer handling for latency extraction by checking whether “ms” was successfully found (extracting the number)

·       Verified the latency parser

o  Located time=

o  Extracted Latency text

o  Identified numerical value

o   Converting “[String]” à double

·       Tested program with multiple real DNS servers to verify successful connections

·       Kept detailed debugging output in terminal (eg. Time= …) to verify source code is running properly

·       Edited a few comments to be accurate/up to date

·       Began real world analysis and data collection (very important for future)

·       Refined the project’s architecture and
long-term direction: desktop application as the actual tool + website as the project’s documentation, research, data, and presentation layer

o   Further down the road when I begin developing the GUI/user interface

o   Reasoning for choosing desktop app as tool: websites would only run ping analysis from my computer, not from user’s computer

Day 7 – 8/23/26 – Development and Debugging

Improved survey/user-flow logic

Changed the survey from automatically terminating the program when
the user selects “no.”

Added an option for users to skip the survey and continue to
the Wi-Fi Latency Analyzer.

Added if / else if / else control flow to handle valid
and invalid responses.

Improved input validation

Continued using equalsIgnoreCase() so inputs such as YES, Yes, and yes are treated consistently.
Added handling for invalid responses instead of allowing unexpected
input to break the program.
Identified and corrected an issue where multiple scanner.nextLine() calls were accidentally being
used before the program needed the second input.

Debugging and code cleanup

Identified a major issue where scanner.close() was
accidentally placed inside the age-validation loop.
Recognized that closing the scanner could prevent the rest of
program from receiving user input.
Kept scanner closure at the end of the program instead.

·       
Began Day 7 latency extraction

Built on the existing BufferedReader that reads
the operating system’s ping output.
Added detection for lines containing “time=”.
Used indexOf() to locate the position of the
latency information within the ping output.
Began learning how substring() can isolate the latency portion
of the returned text.
Next step of extracting the numerical ms value and converting it
with Double.parseDouble()

Improved program methodology

Continued developing the project incrementally
Practiced debugging by testing individual sections

Key challenge/cool change: The program is becoming more user-friendly and robust. Users can
now decline the optional survey without losing access to the actual
Wi-Fi Latency Analyzer, while the program separately handles survey
consent and analyzer participation.

Day 5 — Detecting Ping Success or Failure.

Today I implemented and debugged the logic needed to determine whether a real ping to a DNS server succeeds or fails. I learned how ProcessBuilder, waitFor(), and exit codes work together to interact with the operating system, and how they actually evaluate the result of a network test. I also strengthened my understanding of input validation, control flow, methods, and user inputs, including using if/else if/else logic and System.exit(0) terminating the program. I tested the program with both valid and invalid targets and confirmed that it can now identify successful and unsuccessful connections. I also updated my README to better reflect the project’s current development.

Next: Day 6 — extract the latency measurement in milliseconds from successful ping results.

Day 4 progress:
I broke my Ping Latency Analyzer’s source code into two classes: one handling the intro, simple setup, and survey questions, and the other managing the actual ping measurements and user input. Most of today was spent debugging and reorganizing that structure, and I started tracking my work directly in comments (e.g., // Day4:) to keep changes easy to follow over time. I also ensure the project used a single, consistent Scanner object in the Main class instead of creating multiple instances. On the technical side, I learned how ProcessBuilder, Process, start(), and getInputStream() work together to launch and read output from an external process, and I looked into the difference between declaring void on a main method versus omitting it. I applied .equalsIgnoreCase() to make my survey questions case-insensitive, and I compared using while loops versus if/else blocks for validating user input, particularly useful for handling simple yes/no responses.

Day 2/3:

Learned what a target like Cloudfare or Google DNS is within the world of Cloud and Data Engineering. Public IP Addresses for Website Domains. Learned Arrays/List ( [] ). Learned purpose of Classes/Objects (other than Public Class). Create a numbered menu with safe public test targets. Cloudfare: 1.1.1.1; Google DNS: 8.8.8.8. Let the user choose one target. Print the chosen target back to them

Day 1:

Hi! My name is Aaryan, and this is the very beginning of my journey towards creating my first long-term project with Java. I am very new to Java and this program, and the code below represents the beginning of my User Info data collection for my Wi-Fi Latency Analyzer Project. Any comments or suggestions towards my project would be well appreciated! This is NOT a traditional Wi-Fi speed test, and I am aiming to measure metrics like Packet Loss, Latency, and stability of connections during gaming and video calls.