function buildPersonalWebsite() {
  const developer = new Developer('Enes Arıkan');
  const skills = ['React', 'TypeScript', 'Next.js', 'TailwindCSS'];
  
  developer.setExperience([
    { role: 'QA Engineer', company: 'Insider', years: 2 },
    { role: 'Software Tester', company: 'Various', years: 3 }
  ]);
  
  const projects = developer.createProjects([
    'E-commerce Platform',
    'Task Management App', 
    'Weather Dashboard',
    'Portfolio Website'
  ]);
  
  return {
    portfolio: developer.showcase(projects),
    blog: developer.shareKnowledge(),
    contact: developer.getContactInfo(),
    playground: developer.createInteractiveGames()
  };
}

class CareerJourney {
  constructor() {
    this.levels = [];
    this.currentLevel = 0;
    this.experience = 0;
  }
  
  addExperience(role, company, duration) {
    this.levels.push({
      title: role,
      company: company,
      duration: duration,
      skills: this.getSkillsForRole(role)
    });
    this.levelUp();
  }
  
  levelUp() {
    this.currentLevel++;
    this.experience += 100;
    console.log(`Level up! Now at level ${this.currentLevel}`);
  }
  
  getSkillsForRole(role) {
    const skillMap = {
      'QA Engineer': ['Testing', 'Automation', 'Bug Tracking'],
      'Frontend Developer': ['React', 'JavaScript', 'CSS'],
      'Full Stack Developer': ['Node.js', 'Databases', 'APIs']
    };
    return skillMap[role] || [];
  }
}

// Initialize the journey
const career = new CareerJourney();
career.addExperience('QA Engineer', 'Insider', '2 years');

// Bug hunting mini-game logic
function createBugHunt() {
  const bugs = [
    { type: 'NullPointerException', severity: 'high' },
    { type: 'RaceCondition', severity: 'critical' },
    { type: 'MemoryLeak', severity: 'medium' },
    { type: 'InfiniteLoop', severity: 'high' }
  ];
  
  return {
    findBugs: () => bugs.filter(bug => bug.severity === 'high'),
    fixBug: (bugId) => console.log(`Fixed bug: ${bugId}`),
    score: bugs.length * 10
  };
}

// Skill tree implementation
const skillTree = {
  frontend: {
    react: { level: 5, unlocked: true },
    typescript: { level: 4, unlocked: true },
    nextjs: { level: 4, unlocked: true }
  },
  testing: {
    automation: { level: 5, unlocked: true },
    manual: { level: 5, unlocked: true },
    performance: { level: 3, unlocked: true }
  },
  tools: {
    git: { level: 4, unlocked: true },
    docker: { level: 2, unlocked: false },
    kubernetes: { level: 1, unlocked: false }
  }
};

export default buildPersonalWebsite;
Back to Blog
iPhone representing iOS app development
January 10, 2024·iOS Development

Building AI-Powered iOS Apps

Creating Animetous showed me how to blend machine learning with native iOS development. The technical challenges were worth it.

SwiftiOSAI/ML

I've built several AI-powered iOS apps as personal projects and experiments under Dainty Apps Lab. While the journey wasn't linear, it taught me everything about integrating machine learning with native iOS development — and how to ship something that actually runs well on real devices.

The Question That Started It All

It began with a simple question: can I make AI work smoothly on mobile without an internet connection? On-device processing, full privacy, no latency from API calls. The answer required mastering several complex, interconnected technologies at once.

What I Built

Photo Enhancement App: Real-time image processing using Core ML with custom-trained models for different artistic styles. Everything processed on-device for privacy — no image ever leaves the phone.

Text Analysis Tool: Natural language processing for content analysis, sentiment detection, and keyword extraction. Built specifically to work offline so it could handle sensitive documents without network exposure.

Computer Vision Experiments: Object detection and classification with real-time camera feed. This pushed me hardest on memory management and performance optimization.

The Technical Reality

Building AI apps meant mastering several interconnected layers:

  • Core ML — Apple's on-device ML framework, the foundation of everything
  • Vision Framework — image analysis and processing pipelines
  • Create ML — custom model training without leaving the Apple ecosystem
  • Swift / UIKit — keeping the native layer performant while AI runs underneath

The real challenges weren't the algorithms — they were the constraints. Making AI models small enough for mobile (I reduced 180MB models to 45MB), processing high-res images without memory crashes, and keeping the UI responsive during heavy computation all required solutions that tutorials don't cover.

Performance Lessons Learned

Mobile AI is fundamentally about optimization, not capability:

Model size vs. accuracy: Quantization techniques reduced model sizes by 60–75% while maintaining 90%+ accuracy. A smaller model that works is better than a larger model that crashes.

Memory management: Processing images in chunks, implementing aggressive cleanup after each operation, and responding to memory warnings before iOS forces a crash — these patterns became second nature.

User experience: Real-time progress indicators, low-resolution previews for instant feedback, and smart caching to avoid reprocessing. The AI being slow is acceptable; the app feeling slow is not.

How This Changed My QA Approach

Building AI apps transformed how I test mobile applications professionally. I now understand memory leak patterns in AI workloads, know how to profile CPU usage during intensive operations, and can identify battery drain issues from sustained processing.

More importantly, I learned that AI apps fail in unique ways. Edge cases aren't just about inputs — they're about device states, model confidence thresholds, and graceful degradation when the AI output isn't reliable enough to show.

Where the Technology Is Heading

The trajectory is clear: smaller, more efficient models running entirely on-device. Apple's Neural Engine gets more powerful with each chip generation. Privacy-preserving local AI is becoming the expectation rather than the premium feature.

The developers who understand both the ML layer and the native platform layer will be building the most interesting things in the next few years.

See the projects page for my published apps under Dainty Apps Lab.