azpect/hhargreaves.net
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects Releases Wiki Activity

DELETE: Removed the journal entries.

Browse Source 
For now, there is nothing, I didn't actually write those.
This commit is contained in:
Hayden Hargreaves 2025-02-24 16:58:25 -07:00
parent 80b5161c24
commit 230efb60f1
4 changed files with 0 additions and 793 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
src/journal/.gitkeep Normal file
View File

645
src/journal/Markdown Parser Edge Cases.md
View File

@ -1,645 +0,0 @@
Date: 2025-02-23
Desc: Testing the markdown parser with various elements and edge cases.
# H1 Tag
## H2 Tag
### H3 Tag
#### H4 Tag
##### H5 Tag
###### H6 Tag
| Header 0 | Header 1 | Header 2 | Header 3 |
|---|---|---|---|
|Cell 0 | Cell 1 | Cell 2 | This cell is really big so it will hopefully overflow........This cell is really big so it will hopefully overflow..........This cell is really big so it will hopefully overflow......... |
| Cell 3 | Cell 4 | Cell 5 | Cell 6 |
*This text is italic*
**This text is bold**
***This text is bold and italic***
[This is an anchor](https://www.youtube.com), but this is not.
This is a journal post about something. It's really interesting. I hope you enjoy it.
# Markdown Quirks and Edge Cases
## Emphasis and Strong Emphasis
*This text is emphasized.*
_This text is also emphasized._
**This text is strong emphasis.**
__This text is also strong emphasis.__
* Item 1
* Item 2
* Item 3
+ Another Item 1
+ Another Item 2
1. Yet Another Item 1
2. Yet Another Item 2
***This text is both emphasized and strong!***
___This text is also both emphasized and strong!___
## Strikethrough
~~This text is strikethrough.~~
## Links
[Link to Google](https://www.google.com)
[Link with title](https://www.google.com "Google's Homepage")
[Relative link](/some/page)
[Link with spaces in URL](https://www.google.com/search?q=hello%20world)
<https://www.google.com> (Auto-linked URL)
## Images
![Alt text for image](https://www.example.com/image.jpg)
![Alt text with title](https://www.example.com/image.jpg "Image title")
![Image with spaces in URL](https://www.example.com/image%20with%20spaces.png) (URL encoded spaces)
## Code
`Inline code`
```javascript
// Code block with language specified
function myFunction() {
console.log("Hello, world!");
}
```
My favorite color is red.
```cpp
// C++
#include <iostream>
#include <vector>
#include <string>
#define string "HELLO"
int main() {
// Templates
template <typename T>
T max(T a, T b) {
return (a > b) ? a : b;
}
// Lambda expressions
auto lambda = [](int x) { return x * x; };
// Smart pointers
std::unique_ptr<int> ptr = std::make_unique<int>(42);
// Raw strings (C++11)
std::string raw_string = R"(This is a raw string.\nIt can contain backslashes and quotes: " ' \ )";
// Variadic templates (C++11)
template<typename... Args>
void print_all(Args... args) {
(std::cout << ... << args) << std::endl;
}
// constexpr (C++11)
constexpr int factorial(int n) {
return (n <= 1) ? 1 : (n * factorial(n-1));
}
// Namespaces
namespace my_namespace {
void my_function() {
std::cout << "Hello from my_namespace!" << std::endl;
}
}
// Operator overloading
class MyClass {
public:
int value;
MyClass(int v) : value(v) {}
MyClass operator+(const MyClass& other) const {
return MyClass(value + other.value);
}
};
// Comments (including tricky ones)
// This is a single-line comment.
/*
This is a
multi-line comment.
*/
// /* Nested comment */ <- tricky!
// Unicode characters
std::string unicode_string = "你好世界"; // Hello, world in Chinese
return 0;
}
```
```go
// Go
package main
import "fmt"
func main() {
// Functions with multiple return values
func add_and_subtract(a, b int) (int, int) {
return a + b, a - b
}
// Structs
type Person struct {
Name string
Age int
}
// Methods
func (p Person) Greet() {
fmt.Println("Hello, my name is", p.Name)
}
// Interfaces
type Greeter interface {
Greet()
}
// Goroutines and channels
go func() {
fmt.Println("This is a goroutine")
}()
ch := make(chan int)
go func() {
ch <- 42
}()
fmt.Println(<-ch)
// Slices and arrays
numbers := []int{1, 2, 3, 4, 5}
slice := numbers[1:3]
// Maps
ages := map[string]int{
"Alice": 30,
"Bob": 25,
}
// Comments (including tricky ones)
// This is a single-line comment.
/*
This is a
multi-line comment.
*/
// /* Nested comment */ <- tricky!
// Unicode characters
unicodeString := "你好世界"
// Type switch
var i interface{} = 123
switch v := i.(type) {
case int:
fmt.Println("Integer:", v)
default:
fmt.Println("Other type")
}
// Defer statements
defer fmt.Println("This will be printed last")
// Error handling
result, err := divide(10, 0)
if err != nil {
fmt.Println("Error:", err)
} else {
fmt.Println("Result:", result)
}
}
func divide(a, b int) (int, error) {
if b == 0 {
return 0, fmt.Errorf("division by zero")
}
return a / b, nil
}
```
```js
// JavaScript
// Function with parameters and return value
function greet(name, greeting = "Hello") {
return `${greeting}, ${name}!`;
}
// Arrow function
const multiply = (a, b) => a * b;
// Object literal
const person = {
name: "Alice",
age: 30,
greet: function() {
console.log(`My name is ${this.name}.`);
}
};
// Array methods
const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(num => num * 2);
// Promises and async/await
async function fetchData() {
const response = await fetch('https://example.com/data');
const data = await response.json();
return data;
}
// Class definition
class Dog {
constructor(name, breed) {
this.name = name;
this.breed = breed;
}
bark() {
console.log("Woof!");
}
}
// Comments: single-line and multi-line
// This is a single-line comment.
/*
This is a
multi-line comment.
*/
// Regular expressions
const regex = /^[a-zA-Z]+$/;
// Destructuring
const { name, age } = person;
// Template literals
const message = `Name: ${name}, Age: ${age}`;
// TypeScript (If your highlighter supports it)
// interface Person {
// name: string;
// age: number;
// }
// function greet(person: Person): string {
// return `Hello, ${person.name}!`;
// }
```
```json
{
"name": "John Doe",
"age": 30
}
```
```html
<!DOCTYPE html>
<html>
<head>
<title>Test</title>
</head>
<body>
<h1>Hello world</h1>
</body>
```
```css
@import 'tailwindcss';
/* This is very painful. There must be a better way. */
@layer base {
pre {
background-color: #191724;
/* background-color: red; */
/* Or any color you want */
padding: 0.5rem 2rem;
margin-inline: 2%;
/* Adjust padding as needed */
border-radius: 10px;
/* Optional: Add rounded corners */
overflow-x: auto;
/* Handle horizontal overflow if code is wider */
white-space: pre-wrap;
/* Allows code to wrap within the pre element*/
}
code.hljs {
color: #e0def4;
}
.hljs-string,
.hljs-number,
.hljs-meta {
color: #f6c177;
}
.hljs-punctuation,
.hljs-operator {
color: #908caa;
}
.hljs-comment {
color: #6e6a86;
}
.hljs-keyword {
color: #31748f;
}
.hljs-params {
color: #c4a7e7;
}
.hljs-variable,
.hljs-attr {
color: #e0def4;
}
.language_ {
color: #eb6f92;
}
.function_,
.hljs-literal,
.hljs-built_in,
.hljs-title,
code.language-python .hljs-built_in,
code.language-go .hljs-built_in {
color: #ebbcba;
}
.hljs-property,
.class_,
.hljs-type,
.hljs-tag,
.hljs-selector-tag,
code.language-ts .hljs-built_in {
color: #9ccfd8;
}
}
```
```rs
fn main() {
// A simple function to add two numbers
fn add(a: i32, b: i32) -> i32 {
a + b
}
// A struct representing a point in 2D space
struct Point {
x: f64,
y: f64,
}
impl Point {
// Method to calculate the distance from the origin
fn distance_from_origin(&self) -> f64 {
(self.x * self.x + self.y * self.y).sqrt()
}
}
// Example usage
let num1 = 10;
let num2 = 20;
let sum = add(num1, num2);
println!("The sum of {} and {} is {}", num1, num2, sum);
let point = Point { x: 3.0, y: 4.0 };
let distance = point.distance_from_origin();
println!("The distance of the point from the origin is {}", distance);
// Demonstrating a for loop
for i in 0..5 {
println!("Value of i: {}", i);
}
// Example of a vector
let mut my_vector = vec![1, 2, 3];
my_vector.push(4);
println!("My vector: {:?}", my_vector);
// Using a Result to handle potential errors
fn divide(a: i32, b: i32) -> Result<i32, String> {
if b == 0 {
Err("Cannot divide by zero".to_string())
} else {
Ok(a / b)
}
}
let result = divide(10, 2);
match result {
Ok(value) => println!("Result of division: {}", value),
Err(error) => println!("Error: {}", error),
}
let result2 = divide(10, 0);
match result2 {
Ok(value) => println!("Result of division: {}", value),
Err(error) => println!("Error: {}", error),
}
// Example of a closure
let square = |x: i32| -> i32 { x * x };
println!("Square of 5: {}", square(5));
// String manipulation
let my_string = "Hello, world!".to_string();
let greeting = format!("Greeting: {}", my_string);
println!("{}", greeting);
// Option example
let optional_value: Option<i32> = Some(42);
match optional_value {
Some(value) => println!("Optional value: {}", value),
None => println!("No value present"),
}
}
```
```python
# Python
# Function definition
def greet(name, greeting="Hello"):
return f"{greeting}, {name}!"
# List comprehension
numbers = [1, 2, 3, 4, 5]
doubled = [num * 2 for num in numbers]
# Dictionary
person = {
"name": "Alice",
"age": 30,
"greet": lambda self: print(f"My name is {self['name']}."),
}
# Class definition
class Dog:
def __init__(self, name, breed):
self.name = name
self.breed = breed
def bark(self):
print("Woof!")
# Comments: single-line and multi-line
# This is a single-line comment.
"""
This is a
multi-line comment.
"""
# Try-except block
try:
result = 10 / 0
except ZeroDivisionError:
print("Cannot divide by zero.")
# For loop
for i in range(5):
print(f"Value of i: {i}")
# While loop
count = 0
while count < 3:
print(f"Count: {count}")
count += 1
# String formatting
message = "Name: {}, Age: {}".format(person["name"], person["age"])
# f-strings (formatted string literals)
message2 = f"Name: {person['name']}, Age: {person['age']}"
# List slicing
my_list = [10, 20, 30, 40, 50]
slice_of_list = my_list[1:4]
# Tuple unpacking
coordinates = (10, 20)
x, y = coordinates
# Decorators
def my_decorator(func):
def wrapper():
print("Something is happening before the function is called.")
func()
print("Something is happening after the function is called.")
return wrapper
@my_decorator
def say_hello():
print("Hello!")
```
```java
// Java
// Class definition
public class Main {
// Main method
public static void main(String[] args) {
// Variables and data types
int age = 30;
String name = "Alice";
double height = 5.8;
boolean isStudent = true;
// Conditional statement
if (age >= 18) {
System.out.println("Adult");
} else {
System.out.println("Minor");
}
// Loops
for (int i = 0; i < 5; i++) {
System.out.println("Value of i: " + i);
}
// While loop
int count = 0;
while (count < 3) {
System.out.println("Count: " + count);
count++;
}
// Arrays
int[] numbers = {1, 2, 3, 4, 5};
// Methods
greet(name);
// Object creation
Person person = new Person(name, age);
person.greet();
// Try-catch block
try {
int result = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Cannot divide by zero.");
}
// Comments: single-line and multi-line
// This is a single-line comment.
/*
This is a
multi-line comment.
*/
// String concatenation
String message = "Hello, " + name + "!";
System.out.println(message);
}
// Method definition
public static void greet(String name) {
System.out.println("Hello, " + name + "!");
}
}
// Class definition
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void greet() {
System.out.println("My name is " + this.name + ".");
}
}
```

64
src/journal/Neovim: A Robust Alternative to Visual Studio Code.md
View File

@ -1,64 +0,0 @@
Date: 2025-02-24
Desc: A comparison of performance, extensibility, modal editing, community, and popularity.
# Neovim: A Robust Alternative to Visual Studio Code
###### Author: Hayden Hargreaves
###### Date: February 24, 2025
<br />
In the realm of text editors and integrated development environments (IDEs), developers often find themselves choosing between feature-rich platforms like Visual Studio Code (VS Code) and minimalist, highly customizable editors like Neovim. This article explores why Neovim stands out as a strong choice, comparing it to VS Code, and incorporating insights from user experiences and surveys.
## Performance and Resource Usage
One of the primary advantages of Neovim is its performance. Neovim is designed to be lightweight, leading to faster startup times and lower memory consumption compared to VS Code. Users have noted:
> "Neovim is the clear winner. It is really fast starting up, there is almost no lag..."
This efficiency is particularly beneficial for developers working on large projects or those who prefer a snappy editing experience.
## Extensibility and Customization
Neovim offers extensive customization through its plugin ecosystem, allowing developers to tailor their editing environment to their specific needs. While VS Code also supports extensions, Neovim's approach provides deeper integration and flexibility. A user shared:
> "Neovim had a great plugin ecosystem... I started to understand the value of minimalism and how simplifying your setup can make you more productive."
For example, integrating a Language Server Protocol (LSP) in Neovim can be achieved with the following configuration:
```lua
-- Install 'nvim-lspconfig' plugin first
local lspconfig = require('lspconfig')
lspconfig.pyright.setup{} -- Python LSP
```
In contrast, setting up Python support in VS Code involves installing the Python extension from the marketplace, which provides similar functionality but with less opportunity for customization.
## Modal Editing Efficiency
Neovim inherits Vim's modal editing, enabling developers to perform complex text manipulations with minimal keystrokes. This feature can lead to increased productivity once mastered. For instance, deleting all lines containing a specific word in Neovim can be done with:
```vim
:g/word/d
```
Achieving the same in VS Code would typically require using the search functionality combined with manual deletion or a multi-cursor approach, which can be more time-consuming.
## Community and Ecosystem
While VS Code boasts a large user base, Neovim's community is known for its focus on innovation and embracing new features. This environment fosters rapid development of plugins and enhancements. As noted in a discussion:
> "Neovim has a much larger community that tends to be much more welcoming to new features."
> DEV.TO
## Popularity and Adoption
According to the 2024 Stack Overflow Developer Survey, Visual Studio Code remains the preferred IDE among developers, with 73.6% of respondents reporting its use.
> While Neovim's user base is smaller in comparison, its users often advocate for its efficiency and customization capabilities.
## Conclusion
Choosing between Neovim and Visual Studio Code depends on individual workflow preferences and project requirements. Neovim offers a performance-oriented, highly customizable environment that appeals to developers who value efficiency and control. Conversely, VS Code provides a user-friendly interface with extensive built-in features, suitable for those seeking convenience and a broad extension marketplace.
For a more in-depth comparison and personal experiences transitioning from VS Code to Neovim, consider watching the following video:
[7 Reasons I Chose Neovim Over VSCode](https://www.youtube.com/watch?v=vjzp_IpD61Y)

84
src/journal/Programming: From Gemini.md
View File

@ -1,84 +0,0 @@
Date: 2025-02-24
Desc: A silly article from Gemini.
# Diving Deep into the World of Programming: A Journey of Logic and Creativity
Programming, in its essence, is the art and science of communicating with computers. It's about crafting a precise sequence of instructions, a "program," that dictates every step a machine should take. From the sleek applications on your smartphone to the intricate systems that manage global infrastructure, programming is the invisible hand shaping the technological world we inhabit. It's more than just lines of code; it's the engine of innovation.
## The Art of Problem Solving: Deconstructing the Complex
At its heart, programming is a powerful tool for problem-solving. It's the process of taking a complex challenge, dissecting it into smaller, more manageable components, and then translating those individual pieces into a language that the computer can comprehend. This demands not only logical reasoning and analytical thinking but also a spark of creativity to envision elegant and efficient solutions. It's a continuous cycle of ideation, implementation, testing, and refinement, a process that hones critical thinking skills and fosters a resilient mindset.
## Navigating the Landscape of Programming Languages: A Diverse Ecosystem
The world of programming languages is a vibrant and diverse ecosystem, each language possessing its own unique strengths, weaknesses, and intended applications. Think of them as different tools in a programmer's toolbox.
* **Python:** Often lauded as a beginner-friendly language, Python's clean syntax and readability make it an excellent entry point into the world of coding. Its versatility shines in web development, data science, and scripting.
```python
print("Hello, World!") # A classic Python greeting
```
* **Java:** A robust and platform-independent language, Java is a cornerstone of enterprise-level applications, Android development, and large-scale systems. Its "write once, run anywhere" philosophy has made it a popular choice for cross-platform development.
* **C++:** Renowned for its performance and control, C++ is often the language of choice for game development, system programming, and applications where speed is paramount. Its power comes with added complexity, demanding a deeper understanding of memory management.
* **JavaScript:** The language of the web, JavaScript empowers dynamic and interactive web pages. From simple animations to complex web applications, JavaScript breathes life into the user experience. Its role in front-end and increasingly back-end development makes it an essential skill for web developers.
This is just a glimpse into the vast array of programming languages. Others, like C#, Swift, Go, and Ruby, each cater to specific needs and domains. The selection of a language often hinges on the project's requirements, the programmer's familiarity, and the desired performance characteristics.
## Beyond the Code: The Impact of Programming
Learning to program is an investment that yields substantial returns. It unlocks a plethora of career opportunities, from crafting cutting-edge software to automating mundane tasks. But the benefits extend far beyond career prospects. Programming cultivates invaluable skills, including:
* **Critical Thinking:** Deconstructing problems and formulating logical solutions strengthens analytical abilities.
* **Problem-Solving:** The iterative nature of programming fosters resilience and a systematic approach to tackling challenges.
* **Creativity:** Designing elegant and efficient algorithms requires ingenuity and innovative thinking.
* **Attention to Detail:** The precision demanded by programming hones focus and meticulousness.
## Embarking on Your Programming Journey: A World of Possibilities
Whether your aspirations lie in building immersive games, designing intelligent systems, or simply understanding the technology that surrounds us, programming provides the tools to transform your ideas into reality. It's a journey of continuous learning, exploration, and discovery. Don't be intimidated by the initial complexity. Start with a language that resonates with you, explore online resources, join communities of fellow learners, and embrace the challenges. The world of programming awaits, ready to be shaped by your creativity and ingenuity. So, take the first step, dive into the code, and embark on your own programming adventure!
# Decoding the Matrix: A Deep Dive into the Multifaceted World of Programming
Programming, in its most fundamental form, is the intricate art and science of orchestrating communication with computational machines. It's the meticulous process of constructing a precisely ordered sequence of instructions, a "program," that meticulously dictates every granular step a computer should execute. From the intuitive applications gracing our mobile devices to the complex, interconnected systems underpinning global financial markets, programming is the invisible architect, the silent engine propelling the technological revolution that defines our era. It transcends mere lines of code; it's the very DNA of innovation, the catalyst for progress in the digital age.
## The Architect of Solutions: Deconstructing Complexity, Building Ingenuity
At its core, programming serves as a potent instrument for problem-solving. It's the intellectual endeavor of dissecting a seemingly insurmountable challenge, meticulously fragmenting it into smaller, digestible components, and subsequently translating these individual fragments into a language comprehensible by the computational mind. This process demands not only rigorous logical reasoning and incisive analytical thinking but also a spark of creative ingenuity to envision elegant and optimized solutions. It's an iterative, cyclical process of ideation, implementation, rigorous testing, and continuous refinement, a journey that hones critical thinking faculties and cultivates a resilient, adaptable mindset.
## Navigating the Labyrinth of Programming Languages: A Tapestry of Tools
The realm of programming languages is a dynamic, ever-evolving ecosystem, a vibrant tapestry woven with diverse languages, each possessing its own unique strengths, inherent weaknesses, and intended applications. Envision them as the specialized tools in a programmer's extensive toolkit, each designed for a specific purpose.
* **Python:** Frequently lauded as an ideal entry point for novice programmers, Python's clean, almost human-readable syntax and intuitive structure make it an excellent gateway into the world of coding. Its versatility shines brightly in web development, data science, machine learning, and scripting automation. Its extensive library ecosystem empowers developers to tackle complex tasks with ease.
```python
def factorial(n): # Demonstrating recursion in Python
if n == 0:
return 1
else:
return n * factorial(n-1)
print(factorial(5)) # Output: 120
```
* **Java:** A robust, platform-independent language, Java stands as a cornerstone of enterprise-grade applications, Android mobile development, and large-scale distributed systems. Its "write once, run anywhere" philosophy, facilitated by the Java Virtual Machine (JVM), has cemented its position as a popular choice for cross-platform development. Its object-oriented nature promotes modularity and code reusability.
* **C++:** Renowned for its raw performance, granular control, and low-level access, C++ often reigns supreme in game development, systems programming, high-frequency trading platforms, and applications where execution speed is paramount. Its power, however, comes with increased complexity, necessitating a deeper understanding of memory management, pointers, and object lifetimes.
* **JavaScript:** The undisputed lingua franca of the web, JavaScript empowers dynamic, interactive, and responsive web pages. From subtle animations to complex single-page applications (SPAs), JavaScript breathes life into the user experience. Its ubiquitous presence in both front-end and increasingly back-end development (Node.js) makes it an indispensable skill for modern web developers.
* **Rust:** A rising star in the systems programming world, Rust focuses on memory safety and concurrency without sacrificing performance. Its ownership and borrowing system ensures memory safety at compile time, eliminating many common bugs that plague C and C++ developers. This makes it ideal for building reliable and performant systems.
This is but a fleeting glimpse into the vast, ever-expanding universe of programming languages. Others, such as C#, Swift, Go, Kotlin, and Ruby, each cater to specific niches, domains, and paradigms. The selection of a particular language often hinges on the project's unique requirements, the programmer's individual familiarity and expertise, and the desired performance characteristics. Considerations like community support, available libraries, and tooling also play a significant role.
## Beyond the Lines of Code: The Profound Impact of Programming
Acquiring the skills of programming is an investment that yields substantial, long-lasting returns. It unlocks a plethora of career pathways, from crafting cutting-edge software and pioneering artificial intelligence to automating tedious processes and securing digital infrastructure. However, the benefits extend far beyond mere career advancement. Programming cultivates a range of invaluable cognitive skills:
* **Advanced Critical Thinking:** The process of deconstructing complex problems and formulating logical, algorithmic solutions strengthens analytical abilities and sharpens the mind.
* **Systematic Problem-Solving:** The iterative, experimental nature of programming fosters resilience, cultivates a systematic approach to tackling challenges, and promotes a growth mindset.
* **Creative Algorithmic Thinking:** Designing elegant, optimized, and efficient algorithms demands ingenuity, innovative thinking, and a knack for visualizing abstract processes.
* **Meticulous Attention to Detail:** The inherent precision demanded by programming hones focus, cultivates meticulousness, and emphasizes the importance of accuracy.
* **Abstraction and Generalization:** Identifying patterns and generalizing solutions to broader classes of problems fosters a deeper understanding of underlying principles.
## Embarking on Your Programming Odyssey: A Universe of Possibilities
Whether your aspirations lie in architecting immersive virtual worlds, designing intelligent autonomous systems, or simply gaining a deeper understanding of the technological fabric that surrounds us, programming provides the essential tools to translate your ideas into tangible realities. It's a continuous journey of learning, exploration, and discovery, a path that demands dedication and perseverance but rewards with profound intellectual satisfaction. Don't be daunted by the initial complexity; embrace the challenge. Begin with a language that resonates with your interests, explore the vast landscape of online resources, engage with vibrant communities of fellow learners, and persevere through the inevitable obstacles. The universe of programming awaits, ready to be shaped by your unique creativity, ingenuity, and passion. So, take the first step, delve into the code, and embark on your own programming odyssey!