const algorithms = {
  sort: (arr) => arr.sort((a, b) => a - b),
  search: (arr, target) => {
    return arr.findIndex(x => x === target);
  }
};

interface Portfolio {
  projects: Project[];
  skills: string[];
  experience: number;
}

type Status = 'active' | 'archived';

async function deployProject(id: string) {
  const validated = await validate(id);
  if (validated) {
    return deploy(id);
  }
  throw new Error('Validation failed');
}

class CodeMaster {
  constructor(private skills: string[]) {}
  
  async learn(newSkill: string) {
    this.skills.push(newSkill);
    return this.practice(newSkill);
  }
}

const developer = {
  name: 'Admin',
  skills: ['React', 'TypeScript', 'Next.js'],
  passion: 'Building amazing things',
  coffee: Infinity
};

const algorithms = {
  sort: (arr) => arr.sort((a, b) => a - b),
  search: (arr, target) => {
    return arr.findIndex(x => x === target);
  }
};

interface Portfolio {
  projects: Project[];
  skills: string[];
  experience: number;
}

type Status = 'active' | 'archived';

async function deployProject(id: string) {
  const validated = await validate(id);
  if (validated) {
    return deploy(id);
  }
  throw new Error('Validation failed');
}

class CodeMaster {
  constructor(private skills: string[]) {}
  
  async learn(newSkill: string) {
    this.skills.push(newSkill);
    return this.practice(newSkill);
  }
}

const developer = {
  name: 'Admin',
  skills: ['React', 'TypeScript', 'Next.js'],
  passion: 'Building amazing things',
  coffee: Infinity
};

import { useMemo, useCallback } from 'react';

const optimized = useMemo(() => {
  return expensiveOperation(data);
}, [data]);

interface Portfolio {
  projects: Project[];
  skills: string[];
  experience: number;
}

type Status = 'active' | 'archived';

export default function App() {
  const [state, setState] = useState({
    loading: false,
    data: null,
    error: null
  });
  
  return <Portfolio {...state} />;
}

const stack = {
  frontend: ['React', 'TypeScript', 'Tailwind'],
  backend: ['Node.js', 'Express', 'PostgreSQL'],
  tools: ['Git', 'Docker', 'CI/CD']
};

function buildPortfolio() {
  const projects = await fetchProjects();
  return projects.map(project => ({
    ...project,
    status: 'deployed'
  }));
}

import { useMemo, useCallback } from 'react';

const optimized = useMemo(() => {
  return expensiveOperation(data);
}, [data]);

interface Portfolio {
  projects: Project[];
  skills: string[];
  experience: number;
}

type Status = 'active' | 'archived';

export default function App() {
  const [state, setState] = useState({
    loading: false,
    data: null,
    error: null
  });
  
  return <Portfolio {...state} />;
}

const stack = {
  frontend: ['React', 'TypeScript', 'Tailwind'],
  backend: ['Node.js', 'Express', 'PostgreSQL'],
  tools: ['Git', 'Docker', 'CI/CD']
};

function buildPortfolio() {
  const projects = await fetchProjects();
  return projects.map(project => ({
    ...project,
    status: 'deployed'
  }));
}

const algorithms = {
  sort: (arr) => arr.sort((a, b) => a - b),
  search: (arr, target) => {
    return arr.findIndex(x => x === target);
  }
};

// Clean code is not written by following rules
// Clean code is written by developers who care

const quality = 'maintainability' + 'readability';

async function deployProject(id: string) {
  const validated = await validate(id);
  if (validated) {
    return deploy(id);
  }
  throw new Error('Validation failed');
}

function buildPortfolio() {
  const projects = await fetchProjects();
  return projects.map(project => ({
    ...project,
    status: 'deployed'
  }));
}

interface Portfolio {
  projects: Project[];
  skills: string[];
  experience: number;
}

type Status = 'active' | 'archived';

const algorithms = {
  sort: (arr) => arr.sort((a, b) => a - b),
  search: (arr, target) => {
    return arr.findIndex(x => x === target);
  }
};

// Clean code is not written by following rules
// Clean code is written by developers who care

const quality = 'maintainability' + 'readability';

async function deployProject(id: string) {
  const validated = await validate(id);
  if (validated) {
    return deploy(id);
  }
  throw new Error('Validation failed');
}

function buildPortfolio() {
  const projects = await fetchProjects();
  return projects.map(project => ({
    ...project,
    status: 'deployed'
  }));
}

interface Portfolio {
  projects: Project[];
  skills: string[];
  experience: number;
}

type Status = 'active' | 'archived';

export default function App() {
  const [state, setState] = useState({
    loading: false,
    data: null,
    error: null
  });
  
  return <Portfolio {...state} />;
}

async function deployProject(id: string) {
  const validated = await validate(id);
  if (validated) {
    return deploy(id);
  }
  throw new Error('Validation failed');
}

function buildPortfolio() {
  const projects = await fetchProjects();
  return projects.map(project => ({
    ...project,
    status: 'deployed'
  }));
}

interface Portfolio {
  projects: Project[];
  skills: string[];
  experience: number;
}

type Status = 'active' | 'archived';

import { useMemo, useCallback } from 'react';

const optimized = useMemo(() => {
  return expensiveOperation(data);
}, [data]);

export default function App() {
  const [state, setState] = useState({
    loading: false,
    data: null,
    error: null
  });
  
  return <Portfolio {...state} />;
}

async function deployProject(id: string) {
  const validated = await validate(id);
  if (validated) {
    return deploy(id);
  }
  throw new Error('Validation failed');
}

function buildPortfolio() {
  const projects = await fetchProjects();
  return projects.map(project => ({
    ...project,
    status: 'deployed'
  }));
}

interface Portfolio {
  projects: Project[];
  skills: string[];
  experience: number;
}

type Status = 'active' | 'archived';

import { useMemo, useCallback } from 'react';

const optimized = useMemo(() => {
  return expensiveOperation(data);
}, [data]);

import { useMemo, useCallback } from 'react';

const optimized = useMemo(() => {
  return expensiveOperation(data);
}, [data]);

function buildPortfolio() {
  const projects = await fetchProjects();
  return projects.map(project => ({
    ...project,
    status: 'deployed'
  }));
}

// Clean code is not written by following rules
// Clean code is written by developers who care

const quality = 'maintainability' + 'readability';

export default function App() {
  const [state, setState] = useState({
    loading: false,
    data: null,
    error: null
  });
  
  return <Portfolio {...state} />;
}

class CodeMaster {
  constructor(private skills: string[]) {}
  
  async learn(newSkill: string) {
    this.skills.push(newSkill);
    return this.practice(newSkill);
  }
}

import { useMemo, useCallback } from 'react';

const optimized = useMemo(() => {
  return expensiveOperation(data);
}, [data]);

function buildPortfolio() {
  const projects = await fetchProjects();
  return projects.map(project => ({
    ...project,
    status: 'deployed'
  }));
}

// Clean code is not written by following rules
// Clean code is written by developers who care

const quality = 'maintainability' + 'readability';

export default function App() {
  const [state, setState] = useState({
    loading: false,
    data: null,
    error: null
  });
  
  return <Portfolio {...state} />;
}

class CodeMaster {
  constructor(private skills: string[]) {}
  
  async learn(newSkill: string) {
    this.skills.push(newSkill);
    return this.practice(newSkill);
  }
}

function buildPortfolio() {
  const projects = await fetchProjects();
  return projects.map(project => ({
    ...project,
    status: 'deployed'
  }));
}

class CodeMaster {
  constructor(private skills: string[]) {}
  
  async learn(newSkill: string) {
    this.skills.push(newSkill);
    return this.practice(newSkill);
  }
}

export default function App() {
  const [state, setState] = useState({
    loading: false,
    data: null,
    error: null
  });
  
  return <Portfolio {...state} />;
}

const algorithms = {
  sort: (arr) => arr.sort((a, b) => a - b),
  search: (arr, target) => {
    return arr.findIndex(x => x === target);
  }
};

// Clean code is not written by following rules
// Clean code is written by developers who care

const quality = 'maintainability' + 'readability';

function buildPortfolio() {
  const projects = await fetchProjects();
  return projects.map(project => ({
    ...project,
    status: 'deployed'
  }));
}

class CodeMaster {
  constructor(private skills: string[]) {}
  
  async learn(newSkill: string) {
    this.skills.push(newSkill);
    return this.practice(newSkill);
  }
}

export default function App() {
  const [state, setState] = useState({
    loading: false,
    data: null,
    error: null
  });
  
  return <Portfolio {...state} />;
}

const algorithms = {
  sort: (arr) => arr.sort((a, b) => a - b),
  search: (arr, target) => {
    return arr.findIndex(x => x === target);
  }
};

// Clean code is not written by following rules
// Clean code is written by developers who care

const quality = 'maintainability' + 'readability';

Privacy Policy

Last updated: January 1, 2025

1. Introduction

Welcome to Erfan Karimi's Portfolio website. This Privacy Policy explains how we collect, use, disclose, and safeguard your information when you visit our website. By using our website, you consent to the data practices described in this policy.

2. Information We Collect

2.1 Personal Information

We may collect personal information that you voluntarily provide to us when you:

Contact us through the contact form (name, email address, message)
Subscribe to our newsletter or blog updates
Interact with our website features (like/dislike buttons on blog posts)

2.2 Automatically Collected Information

When you visit our website, we automatically collect certain information about your device, including:

IP address
Browser type and version
Operating system
Pages you visit and time spent on pages
Referring website addresses

3. How We Use Your Information

We use the information we collect to:

Respond to your inquiries and provide customer support
Improve our website and user experience
Analyze website usage and trends
Prevent fraud and ensure website security
Comply with legal obligations

4. Data Storage and Security

We implement appropriate technical and organizational security measures to protect your personal information. However, no method of transmission over the Internet or electronic storage is 100% secure. While we strive to use commercially acceptable means to protect your information, we cannot guarantee absolute security.

5. Cookies and Tracking Technologies

Our website uses cookies and similar tracking technologies to track activity on our website and store certain information. You can instruct your browser to refuse all cookies or to indicate when a cookie is being sent. For more information, please see our Cookie Policy.

6. Third-Party Services

We may use third-party services that collect, monitor, and analyze information to help us improve our website. These services may have their own privacy policies governing the collection and use of your information.

7. Your Rights

Depending on your location, you may have certain rights regarding your personal information, including:

The right to access your personal information
The right to rectify inaccurate information
The right to request deletion of your information
The right to object to processing of your information
The right to data portability

8. Children's Privacy

Our website is not intended for children under the age of 13. We do not knowingly collect personal information from children under 13. If you believe we have collected information from a child under 13, please contact us immediately.

9. Changes to This Privacy Policy

We may update this Privacy Policy from time to time. We will notify you of any changes by posting the new Privacy Policy on this page and updating the "Last updated" date. You are advised to review this Privacy Policy periodically for any changes.

10. Contact Us

If you have any questions about this Privacy Policy, please contact us through our contact page.