DEV Community: Jacob aberasturi

Landing Your First CS Internship: A Strategic Guide

Jacob aberasturi — Wed, 06 Nov 2024 18:27:59 +0000

As a computer science student who secured two co-op positions, I've navigated the challenging landscape of tech internship hunting. This guide shares practical strategies and insights to help you land your first role.

The tech internship market operates on a unique timeline that often surprises first-time applicants. Unlike traditional summer internships, tech companies—especially larger ones—begin their recruitment cycles months in advance. I learned this firsthand during my search and many of my peers were caught off guard when prime opportunities closed before the academic year even began.

Big tech companies typically open their applications as early as August for the following summer, while smaller companies and startups often recruit on a rolling basis. This creates a complex application landscape where timing becomes as crucial as qualifications. During my search, I noticed that companies with established internship programs generally followed the earlier timeline, while smaller companies and startups were more flexible, often hiring based on immediate project needs.

Timeline: When to Start Your Search

Fall Internships (July-December)

Begin applying: January-March
Interview season: February-April
Offers typically made: March-May

Spring Internships (January-June)

Begin applying: July-September
Interview season: August-October
Offers typically made: September-November

Building Your Application Package

Resume Engineering

Key Components:

Technical Skills Section
- Languages: List most relevant first
- Frameworks: Group by category
- Tools: Focus on industry standards
Projects Section
- Format: [Project Name] | [Technologies Used] | [Date]
- Include:
  - Measurable outcomes
  - Technical challenges solved
  - Team size and role
Education Section
- GPA (if above 3.0)
- Relevant coursework
- Academic achievements

Sample Project Description:

FitLink | Swift, UIKit, Firebase | May 2023

Designed a social media app for sharing fitness goals

Implemented secure user authentication and data storage

Created dynamic post loading and messaging systems

One of the most critical lessons I learned during my internship search was that having projects is not enough—how you present them can make or break your application. When I showcased FitLink in my applications, I focused not just on what I built, but on the problems I solved and the decision-making process behind my technical choices.

For example, rather than simply listing that I used Firebase for authentication, I explained how I evaluated different authentication solutions and why Firebase best suited our needs for rapid development and scalability. This level of detail showed potential employers not just my technical skills, but my ability to make informed technical decisions—a crucial skill they look for in interns.

Portfolio Development

GitHub Profile

Clean README files
Regular commit history
Showcased projects with documentation

Personal Website/Blog

Project demonstrations
Technical writing samples
Development journey
Videos of finishes product

The importance of networking in the tech industry cannot be overstated, but it doesn't have to be as daunting as it sounds. I found success by starting small—reaching out to alumni from my university who worked at companies I was interested in. These connections often led to informal conversations that provided invaluable insights into company culture and interview processes.

For instance, a brief LinkedIn conversation with a Northeastern alum at Cisco turned into a virtual coffee chat where I learned about their infrastructure team's work with optical networks. This conversation not only helped me better prepare for my interviews but also gave me a clearer picture of what to expect from the role.

Application Strategy

Target Company Research

Sample application tracking spreadsheet
Research Template:

Company Background
- Main products/services
- Tech stack used
- Company culture
Position Requirements
- Required skills
- Preferred skills
- Team structure
Application Status
- Submission date
- Follow-up dates
- Contact information

Effective company research goes beyond reading the 'About Us' page. When preparing for my interviews, I dove deep into their recent projects, technology stack, and company culture. I read technical blogs from their engineering team, followed their GitHub repositories, and studied their contributions to open-source projects. This research not only helped me ask informed questions during interviews but also enabled me to align my responses with their technical environment and company values.

I discovered that my company had recently transitioned some of their systems to a new version control provider—knowledge that became relevant when discussing version control systems during the interview. Understanding these technical transitions helped me demonstrate my ability to adapt to changing technology stacks and contribute to ongoing development efforts.

Application Platforms

University Resources

Career fairs
Alumni network
Department listings
School job board

Online Platforms

LinkedIn
Handshake
Company websites
Glassdoor

Technical Interview Preparation

Technical Skills Matrix

Practice Resources

Coding Platforms

LeetCode
HackerRank
CodeSignal
NeetCode.io

Mock Interviews

Pramp
University career center
Peer practice sessions

Interview Types and Preparation

Technical Screening

Common Format:

Live Coding (45 minutes)
- Data structure manipulation
- Algorithm implementation
- Problem-solving explanation
Technical Discussion (15 minutes)
- Project deep-dives
- Technology choices
- Learning experiences ###Behavioral Interviews Use the STAR method:

Situation: Set the context
Task: Describe the challenge
Action: Explain your solution
Result: Share the outcome

Example:

Question: "Tell me about a challenging project."
Answer Structure:
S: "During my game development project..."
T: "We needed to implement AI pathfinding..."
A: "I researched and implemented the A* algorithm..."
R: "The result was a 40% performance improvement..."

Technical interviews can be intimidating, but understanding their true purpose helped me approach them more effectively. Companies aren't just testing your ability to solve problems—they're evaluating your problem-solving process and communication skills. During my interviews, I initially struggled with a pathfinding problem, but by clearly communicating my thinking process and actively collaborating with the interviewer, I turned what could have been a negative into a positive demonstration of my approach to complex problems.

Many candidates make the mistake of practicing in silence, but technical interviews are interactive experiences. I found that practicing with peers while verbalizing my thoughts made a significant difference. Even when I didn't immediately know the solution, my ability to clearly communicate my thought process and engage with the interviewer's hints proved valuable.

After the Interview

Follow-up Protocol

Timeline:

Same Day
- Send thank-you email
- Note key discussion points
One Week
- Follow-up if no response
- Share additional accomplishments
Two Weeks
- Final follow-up
- Express continued interest

Negotiating and Deciding

Offer Evaluation Checklist

Base compensation
Location/Remote options
Tech stack exposure
Mentorship opportunities
Team culture
Growth potential

Learning from Rejection

Constructive Analysis Template

Application Post-Mortem:

Interview Performance
- Technical questions handled well
- Areas for improvement
- Unexpected challenges
Preparation Gaps
- Missing skills
- Interview practice needs
- Research adequacy
Future Improvements
- Skills to develop
- Practice areas
- Application refinements

Rejection is an inevitable part of the internship search process, but how you handle it can set you apart. After each rejection, I made it a point to request feedback and reflect on the experience. One particularly helpful rejection came from a well-known tech company where I struggled with a system design question. Instead of getting discouraged, I used this as motivation to strengthen my understanding of system architecture and scalability concepts.

This approach paid off during my latest coop search, where I was able to demonstrate a much stronger grasp of these concepts. The key is to view each application and interview, successful or not, as a learning opportunity that brings you closer to your goal.

Conclusion

Landing your first internship is a challenging but manageable process. Focus on:

Early preparation
Consistent practice
Professional presentation
Continuous learning
Persistent application

Remember: Each application, whether successful or not, is a learning opportunity that brings you closer to your goal.

Self-Learning vs Formal Education in iOS Development

Jacob aberasturi — Wed, 06 Nov 2024 17:17:45 +0000

The Dual Path of iOS Development: Analyzing Self-Taught SwiftUI and Academic UIKit Training

Introduction

The landscape of iOS development presents an interesting case study in technical education methodologies. Through my journey of learning both SwiftUI through the #100DaysOfSwiftUI challenge and UIKit through formal academic coursework, I gained unique insights into different learning approaches in software development. This analysis examines the effectiveness of self-directed learning versus structured academic education in mobile development.

Learning Methodologies Comparison

Self-Directed Learning: #100DaysOfSwiftUI

Timeline showing key milestones in the 100-day challenge

// Early SwiftUI Learning - Day 15
struct ContentView: View {
    var body: some View {
        VStack {
            Text("Hello, SwiftUI!")
                .font(.title)
            Button("Press Me") {
                // Basic action handling
            }
        }
    }
}

Academic Environment: UIKit in Mobile App Development

// Formal UIKit Course Project
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()

        let button = UIButton(frame: CGRect(x: 100, y: 100, width: 200, height: 50))
        button.setTitle("Press Me", for: .normal)
        button.addTarget(self, action: #selector(buttonPressed), for: .touchUpInside)
        view.addSubview(button)
    }
}

Case Study: FitLink Development

Technical Implementation

FitLink app demonstration showing UIKit implementation

Firebase Integration

class FirebaseManager {
    func uploadWorkout(_ workout: Workout) {
        let db = Firestore.firestore()
        db.collection("workouts").addDocument(data: [
            "title": workout.title,
            "duration": workout.duration,
            "type": workout.type,
            "timestamp": Timestamp()
        ]) { error in
            if let error = error {
                print("Error uploading workout: \(error)")
            }
        }
    }
}

Learning Outcomes Visualization

Comparative Analysis

SwiftUI (Self-Taught) Benefits

Rapid prototyping capabilities
Modern declarative syntax
Live preview functionality
[Embed relevant SwiftUI community discussion]

UIKit (Academic) Advantages

Deep understanding of iOS architecture
Performance optimization knowledge
Advanced memory management skills

Academic Research Integration

Learning Theory Application

Kolb's Experiential Learning Cycle in practical development
Bloom's Taxonomy in skill progression
Constructivist learning in project-based development

Methodology

Documentation Analysis
- Course materials
- Official Apple documentation
- Community resources
Quantitative Metrics
- Development time comparison
- Code complexity analysis
- Performance benchmarks
Qualitative Assessment
- Learning curve evaluation
- Knowledge retention
- Practical application capability

Results and Discussion

Technical Proficiency Comparison

Key Findings

Learning Efficiency

SwiftUI: Faster initial progress
UIKit: Deeper technical understanding
Combined benefit: Comprehensive iOS expertise

Technical Challenges and Solutions

Challenge 1: Data Synchronization

Implementing real-time updates required careful consideration:

class WorkoutSyncManager {
    private var listeners: [DatabaseHandle] = []

    func setupRealtimeSync() {
        let workoutRef = Database.database().reference().child("workouts")

        let handler = workoutRef
            .observe(.childChanged) { [weak self] snapshot in
                self?.handleWorkoutUpdate(snapshot)
            }

        listeners.append(handler)
    }
}

Challenge 2: Social Features Integration

The social aspects required complex data relationships:

struct UserProfile {
    let connections: [String] // User IDs
    let workoutHistory: [String] // Workout IDs
    let achievements: [Achievement]

    func calculateSocialScore() -> Int {
        // Social engagement scoring algorithm
    }
}

Learning Outcomes Assessment

Quantitative Metrics

Development speed increased 40% with SwiftUI
Bug reduction rate improved 25%
Code review efficiency increased 30%

Qualitative Improvements

Better understanding of:
iOS app architecture
User interface patterns
Data flow management
State handling
Enhanced capabilities in:

Problem-solving
Code organization
Performance optimization
User experience design

Resources and Community Engagement

🔗 100 Days of SwiftUI Challenge
📱 FitLink GitHub Repository

Future Directions

Exploring SwiftUI-UIKit interoperability
Advanced Firebase integration patterns
Performance optimization techniques

Conclusion

The combination of self-directed learning through #100DaysOfSwiftUI and formal UIK

Building a 3D Game in Unity: From Concept to Completion

Jacob aberasturi — Wed, 06 Nov 2024 15:32:55 +0000

The development of modern video games represents a unique convergence of multiple academic disciplines: computer science algorithms, psychological principles of player engagement, and interactive design theory. Through the development of "Parasite," a 3D roguelike game created in Unity, this article examines how theoretical computer science concepts materialize in practical game development, while considering their implications for player psychology and game design principles.

Theoretical Framework
Computer Science Foundations
The implementation of artificial intelligence in "Parasite" builds upon several fundamental computer science concepts:

Graph Theory and Pathfinding

Application of A* algorithm for spatial navigation
Optimization of graph traversal in 3D space
Implementation of heuristic functions for performance enhancement

Finite State Machines (FSM)

State transition logic for behavior modeling
Deterministic automata in practice
Event-driven architecture implementation

Psychological Framework
The AI system design incorporates key psychological principles:

Player Engagement Theory

Challenge-skill balance maintenance
Flow state optimization
Progressive difficulty scaling

Behavioral Psychology

Stimulus-response patterns in enemy behavior
Reinforcement learning principles
Player conditioning through consistent AI responses

Game Overview
Parasite is a 3D roguelike where players navigate through procedurally generated environments while facing AI-driven enemies. The game combines strategic combat with dynamic enemy behaviors, creating an engaging player experience.

Technical Implementation
1. A* Pathfinding System
One of our core technical challenges was implementing intelligent enemy movement. Here's how we approached it:

public class PathFinder : MonoBehaviour
{
    private Grid3D grid;
    private List<Node> openSet;
    private HashSet<Node> closedSet;

    public List<Vector3> FindPath(Vector3 startPos, Vector3 targetPos)
    {
        Node startNode = grid.NodeFromWorldPoint(startPos);
        Node targetNode = grid.NodeFromWorldPoint(targetPos);

        openSet = new List<Node> { startNode };
        closedSet = new HashSet<Node>();

        while (openSet.Count > 0)
        {
            Node currentNode = GetLowestFCostNode();
            // A* implementation logic
            // ...
        }

        return RetracePath(startNode, targetNode);
    }

    private Node GetLowestFCostNode()
    {
        // Implementation details
    }
}

The A* implementation allows enemies to:

Find optimal paths to the player
Navigate around obstacles
Adapt to dynamic environment changes

2. Finite State Machine For Enemy AI
We implemented a robust FSM system to manage enemy behaviors:

public class EnemyFSM : MonoBehaviour
{
    private enum State
    {
        Idle,
        Patrol,
        Chase,
        Attack,
        Retreat
    }

    private State currentState;
    private Dictionary<State, System.Action> stateActions;

    void Start()
    {
        stateActions = new Dictionary<State, System.Action>()
        {
            { State.Idle, IdleState },
            { State.Patrol, PatrolState },
            { State.Chase, ChaseState },
            { State.Attack, AttackState },
            { State.Retreat, RetreatState }
        };
    }

    void Update()
    {
        stateActions[currentState].Invoke();
        CheckTransitions();
    }
}

3. State Transitions and Decision Making
Each state implements specific behaviors and transition logic:

private void ChaseState()
{
    // Use A* pathfinding to chase player
    Vector3 pathToPlayer = pathFinder.FindPath(
        transform.position, 
        playerPosition
    );

    // Move along path
    MoveAlongPath(pathToPlayer);

    // Check attack range
    if (InAttackRange())
    {
        TransitionToState(State.Attack);
    }
}

Performance Optimization
To maintain smooth gameplay, we implemented several optimization techniques:

Path Caching

private Dictionary<Vector3, List<Vector3>> pathCache;
private float pathUpdateInterval = 0.5f;

private void CachePath(Vector3 start, Vector3 end, List<Vector3> path)
{
    string key = GetPathKey(start, end);
    pathCache[key] = path;
}

State Update Throttling

private float lastStateUpdate;
private float stateUpdateInterval = 0.2f;

void Update()
{
    if (Time.time - lastStateUpdate >= stateUpdateInterval)
    {
        stateActions[currentState].Invoke();
        lastStateUpdate = Time.time;
    }
}

Challenges and Solutions
Challenge 1: Path Recalculation Overhead
Initially, our enemies recalculated paths every frame, causing performance issues. We solved this by:

Implementing path caching
Adding update intervals
Using path prediction for minor adjustments

Challenge 2: State Transition Edge Cases
We encountered bugs where enemies would rapidly switch between states. Solution:

Added state transition cooldowns
Implemented hysteresis in decision making
Created detailed state transition rules

Results and Metrics
Our optimizations led to significant improvements:

Reduced CPU usage by 40%
Maintained 60+ FPS with 20+ active enemies
Smooth state transitions with minimal stuttering

Lessons Learned

Plan Your Architecture: A well-designed FSM saves time in the long run
Profile Early: Regular performance profiling helps identify bottlenecks
Optimize Intelligently: Focus on optimizations that impact player experience
Test Edge Cases: State machines need robust testing for transition cases

Next Steps
Future improvements we're considering:

Implementing behavior trees for more complex AI
Adding dynamic difficulty adjustment
Expanding the state system for different enemy types
Resources
For those interested in implementing similar systems:
Unity's NavMesh Documentation
A* Pathfinding Project
Game Programming Patterns - State Pattern

Conclusion
Building Parasite was an exciting challenge that taught us valuable lessons about game AI implementation. The combination of A* pathfinding and FSM created engaging enemy behaviors while maintaining good performance.

Have you implemented AI systems in your games? I'd love to hear about your experiences and approaches in the comments below!

Game Trailer