$ whoami
> a guy that likes to make niche things

I'm a passionate developer who believes that choosing the right programming language is like picking the right tool from a Swiss Army knife - it depends entirely on what you're trying to cut, file, or uncork.

I switch programming languages more often than I change my desktop wallpaper (which, to be fair, has been the same "I'll customize it later" default for about 3 years now). When faced with a problem, I don't ask "How can I solve this with [favorite_language]?" but rather "Which language would hate solving this problem the least?"

// My relationship status with technology: "It's complicated"
const me = {
  approach: 'polyglot',
  languages: [
    'TypeScript', 'JavaScript', 'Dart', 'Python', 
    'Go', 'C++', 'PHP', 'SQL', 
    // and whatever I impulsively learned last weekend
  ],
  frameworks: [
    'Flutter', 'React', 'Laravel', 'Vue', 
    'FastAPI', 'Express',
    // ...others I've installed but never actually used
  ],
  tools: [
    'Git', 'Docker', 'VS Code', 'Figma', 'OAuth2.0',
    'Coffee Machine' // my most critical development tool
  ],
  platforms: ['macOS', 'Linux', 'AWS', 'Firebase', 'Mobile'],
  interests: ['UI/UX', 'Developer Tools', 'Security', 'Privacy', 'Mental Health Tech'],
  philosophy: (problem) => findBestToolFor(problem),
  debugStrategy: () => console.log("It worked on my machine! 🤷‍♂️"),
  estimationAccuracy: Date.now() * 2 // always off by a factor of 2
};

A macOS menu bar utility for managing API tokens with GitLab integration. I built it with Flutter because native apps are so 2010. Keeper ensures you'll never have to paste a token from a sticky note again (I know you have them, because I had about 37).

A FOSS mood tracking application with companion self-hosted server. I created this during some dark times as a reminder that not every day is terrible - just most of them! It uses fancy algorithms to tell me what I already know: I'm happier when I sleep more and doomscroll less. Beta release coming Q4 2025 (or whenever my existential dread subsides enough to finish it).

An end-to-end encrypted notes application so secure that sometimes even I can't access my data. Built with Flutter and Python FastAPI because apparently one language wasn't complicated enough for me. Implements zero-trust architecture because I don't even trust my own code (and neither should you).

My first major project—a C++ mod menu for GTA that received the highest honor in software development: a cease and desist letter. What started as a vehicle customization tool evolved into a sophisticated hooking mechanism that impressed everyone except Rockstar's legal team. Nothing says "you've made it" like getting legally threatened before you're old enough to vote.

• Right Tool for the Job: Because forcing everything into JavaScript is like performing surgery with a spoon
• User-First Design: If users need a manual, my UI has already failed
• Clean Architecture: I write code so clean you could eat off it (please don't, I need my laptop)
• Accessibility: Building software that works for everyone, because exclusivity is so Web 1.0
• Open Source: Contributing to the community because karma might help fix those mysterious production bugs I definitely didn't cause

// My coding style: "Consistently inconsistent"
abstract class MyStyle<T, E extends Exception, C extends Coffee> {
  // Language-agnostic principles that transcend my mortal understanding
  
  // Clean, descriptive naming (except when I'm tired)
  final bool usesDescriptiveNames = DateTime.now().hour < 22;
  final Map<String, String> variableNames = {
    'before_coffee': 'x',
    'after_coffee': 'descriptiveAndWellThoughtOutVariableName'
  };
  
  // Choose the right tool for each component
  T selectBestTechnology(Problem problem) {
    if (problem.deadline.isYesterday()) {
      return python; // It's always Python when I'm panicking
    }
    
    return availableTechnologies
        .where((tech) => tech.canSolve(problem))
        .orderBy((tech) => tech.efficiencyFor(problem))
        .first;
  }
  
  // Modular, focused components (in theory)
  List<Component> createComponents() {
    // Start with good intentions
    if (project.isNewAndExciting) {
      return components.map((c) => c.makeModular()).toList();
    } else {
      // Reality sets in around day 3
      return [oneGiantComponentThatDoesEverything];
    }
  }
  
  // Thoughtful error handling
  Future<Result<T>> handleOperation() async {
    try {
      final result = await performOperation();
      return Success<T>(result);
    } catch (e) {
      logError(e);  // With increasingly desperate comments
      return Failure<T>(e);
    }
  }
  
  // Easter eggs and humor
  void addEasterEgg() {
    if (Math.random() < 0.1) {  // 10% chance
      showEasterEgg('🥚');
    } else if (project.hasDeadline && project.client.isTooSerious) {
      addEvenMoreEasterEggs(); // They'll never find them all
    }
  }
  
  // Documentation strategy
  void documentCode() {
    if (willIRememberThisIn6Months == false) {
      addComment("Don't ask how this works, it just does");
    }
  }
}

I'm continuing to explore:

• Cross-platform developer tools that work on every platform (except the one you need)
• Privacy-focused applications (because someone has to fight Big Tech)
• Mental health technology (cheaper than my therapy)
• Secure communication systems (that will be obsolete by quantum computing anyway)
• UI/UX innovations that users will complain about until the next redesign
• Accessibility features that should have been standard 10 years ago

Don't. But if you must just email me and I'll get back to you when I can.

"The best code is no code at all. The second best is code that looks like it doesn't exist."