So I built ftextarea — and used it as an excuse to learn Rust + WebAssembly without frameworks.
Build a static web page with:
]]>This list focuses on side projects and learning goals, I’m keeping personal and work-related resolutions private.
Each goal below includes a measurable target, the bigger picture behind it, and why it matters to me.
I’ll update this post throughout the year with progress notes under each goal. Check back to see how it’s going.
I’ve read great things about keto for general health and weight management. I want to experience what ketosis actually feels like and figure out what it takes to get there. The 30-day target forces me to find a sustainable approach: simple recipes that work with a full-time job and a family at home.
]]>⚠️ PLACEHOLDER CONTENT: This is a fake blog post with dummy content for demonstration purposes only.
Rust’s async/await syntax makes writing asynchronous code feel almost synchronous. Here’s a quick look at how it works.
use tokio::time::{sleep, Duration};
async fn fetch_data(id: u32) -> String {
// Simulate network delay
sleep(Duration::from_millis(100)).await;
format!("Data for item {}", id)
}
#[tokio::main]
async fn main() {
let result = fetch_data(42).await;
println!("{}", result);
}
You can run multiple futures concurrently with tokio::join!:
⚠️ PLACEHOLDER CONTENT: This is a fake blog post with dummy content for demonstration purposes only.
Managing state in Flutter can get messy. Here are some patterns that help.
A simple approach for local state:
class CounterWidget extends StatefulWidget {
const CounterWidget({super.key});
@override
State<CounterWidget> createState() => _CounterWidgetState();
}
class _CounterWidgetState extends State<CounterWidget> {
final _counter = ValueNotifier<int>(0);
@override
Widget build(BuildContext context) {
return ValueListenableBuilder<int>(
valueListenable: _counter,
builder: (context, value, child) {
return Text('Count: $value');
},
);
}
void increment() => _counter.value++;
}
Dart extension methods can clean up your code:
]]>⚠️ PLACEHOLDER CONTENT: This is a fake blog post with dummy content for demonstration purposes only.
Rust’s ? operator makes error propagation elegant:
use std::fs::File;
use std::io::{self, Read};
fn read_config() -> io::Result<String> {
let mut file = File::open("config.toml")?;
let mut contents = String::new();
file.read_to_string(&mut contents)?;
Ok(contents)
}
Define your own errors with thiserror:
use thiserror::Error;
#[derive(Error, Debug)]
pub enum AppError {
#[error("Configuration file not found")]
ConfigNotFound,
#[error("Invalid data: {0}")]
InvalidData(String),
#[error("IO error: {0}")]
Io(#[from] std::io::Error),
}
fn load_config() -> Result<Config, AppError> {
let data = std::fs::read_to_string("config.toml")
.map_err(|_| AppError::ConfigNotFound)?;
parse_config(&data)
.ok_or_else(|| AppError::InvalidData("malformed TOML".into()))
}
For applications (not libraries), anyhow simplifies everything: