Master the key metrics and strategies for analyzing mobile game and app performance. Learn DAU, MAU, retention tactics, gamification, and proven techniques to boost user engagement.

Mobile Game & App Data Analysis: Essential Metrics and Retention Strategies

---
title: "Mobile Game & App Data Analysis: Essential Metrics and Retention Strategies"
date: "2025-07-23"
description: "Master the key metrics and strategies for analyzing mobile game and app performance. Learn DAU, MAU, retention tactics, gamification, and proven techniques to boost user engagement."
slug: "mobile-game-app-data-analysis-best-practices"
tags: "#mobileanalytics #gameanalytics #dataanalytics #userretention #gamification #mobileapps"
author: "Bitscorp"
---

# Mobile Game & App Data Analysis: Essential Metrics and Retention Strategies

In the competitive landscape of mobile games and applications, data-driven decision making isn't just advantageous—it's essential for survival. Understanding your users' behavior, engagement patterns, and retention metrics can mean the difference between a thriving app and one that fades into obscurity.

This comprehensive guide explores the fundamental metrics every mobile game and app developer should track, along with proven strategies to improve user retention and engagement.

## Core Engagement Metrics: The Foundation of Success

### Daily Active Users (DAU)
Daily Active Users represent the number of unique users who engage with your app within a 24-hour period. This metric serves as the pulse of your application's health.

**Why DAU Matters:**
- Immediate feedback on feature releases or updates
- Early warning system for engagement issues
- Foundation for calculating other critical metrics like retention rates

**Best Practices:**
- Define "active" clearly (app open, specific action, minimum session time)
- Track DAU trends over time, not just absolute numbers
- Segment DAU by user acquisition source to identify quality channels

### Weekly Active Users (WAU) and Monthly Active Users (MAU)
WAU and MAU provide broader perspectives on user engagement, smoothing out daily fluctuations and revealing longer-term trends.

**Key Insights:**
- **WAU** helps identify weekly usage patterns and the impact of weekend vs. weekday engagement
- **MAU** reveals monthly retention and seasonal trends
- The ratio of DAU/MAU indicates user engagement intensity (higher ratios suggest more frequent usage)

**Optimization Tips:**
- Aim for a DAU/MAU ratio of 20% or higher for engaged user bases
- Use WAU to plan weekly events or content releases
- Monitor MAU growth rate as a key business health indicator

## Retention Analysis: The Make-or-Break Metric

Retention is arguably the most critical metric for mobile apps and games. It's far more cost-effective to retain existing users than acquire new ones.

### Day 1, Day 7, and Day 30 Retention
- **Day 1 Retention:** Percentage of users who return the day after first install
- **Day 7 Retention:** Users who return within the first week
- **Day 30 Retention:** Long-term retention indicating product-market fit

**Industry Benchmarks:**
- **Mobile Games:** Day 1: 25-30%, Day 7: 10-15%, Day 30: 3-5%
- **Utility Apps:** Day 1: 20-25%, Day 7: 15-20%, Day 30: 8-12%
- **Social Apps:** Day 1: 30-35%, Day 7: 15-25%, Day 30: 8-15%

### Cohort Analysis
Track user groups based on their install date to understand how retention evolves over time and identify the impact of product changes.

**Implementation Strategy:**
- Create weekly or monthly cohorts
- Compare retention curves between different user acquisition channels
- Analyze the impact of onboarding changes on retention curves

## Advanced Metrics for Deeper Insights

### Session Length and Frequency
Understanding how long users spend in your app and how often they return provides insights into engagement quality.

**Key Metrics:**
- Average session duration
- Sessions per user per day
- Time between sessions

### Lifetime Value (LTV) and Revenue Metrics
For monetized apps, tracking revenue metrics alongside engagement data provides a complete picture of user value.

**Essential Revenue Metrics:**
- Average Revenue Per User (ARPU)
- Average Revenue Per Paying User (ARPPU)
- Conversion rate to paying user
- Customer Lifetime Value (CLV)

### Churn Analysis
Identify when and why users stop using your app to implement targeted retention strategies.

**Churn Indicators:**
- Decreasing session frequency
- Shorter session durations
- Lack of engagement with key features
- Time since last meaningful action

## Proven Retention Strategies

### 1. Gamification: Making Engagement Rewarding

Gamification leverages psychological principles to make mundane activities engaging and rewarding.

**Effective Gamification Elements:**
- **Progress Bars:** Visual representation of advancement toward goals
- **Achievement Systems:** Badges and milestones that recognize user accomplishments
- **Leaderboards:** Social competition that drives continued engagement
- **Streaks:** Daily activity chains that create habit formation
- **Level Systems:** Clear progression paths with meaningful rewards

**Implementation Best Practices:**
- Ensure rewards are meaningful and aligned with user goals
- Create multiple progression paths for different user types
- Balance challenge and achievability to avoid frustration
- Use variable reward schedules to maintain engagement

### 2. Daily Bonuses and Reward Systems

Strategic reward distribution can significantly impact user retention and create habitual usage patterns.

**Daily Bonus Strategies:**
- **Escalating Rewards:** Increasing value for consecutive days
- **Weekly Cycles:** Special rewards for completing full weeks
- **Comeback Bonuses:** Special incentives for returning users
- **Milestone Rewards:** Significant bonuses at key intervals (7, 30, 100 days)

**Best Practices:**
- Front-load early rewards to establish habits
- Use push notifications to remind users of unclaimed bonuses
- Create FOMO (fear of missing out) with time-limited offers
- Provide multiple ways to earn rewards beyond just daily logins

### 3. Strategic Push Notifications

Well-crafted push notifications can re-engage dormant users and maintain active user engagement.

**Notification Categories:**
- **Re-engagement:** Bring back users who haven't opened the app recently
- **Achievement:** Celebrate user milestones and accomplishments
- **Social:** Updates about friends' activities or competitive elements
- **Content:** New features, events, or content available
- **Personalized:** Based on individual user behavior and preferences

**Optimization Techniques:**
- A/B test notification copy, timing, and frequency
- Personalize messages based on user behavior and preferences
- Respect user preferences and local time zones
- Use rich notifications with images and interactive elements
- Implement smart timing based on when users are most likely to engage

## Widget Strategies: Learning from Duolingo

Duolingo's home screen widget strategy exemplifies how to maintain app presence and encourage daily engagement.

### Home Screen Widget Best Practices

**Widget Functionality:**
- **Progress Visualization:** Show streaks, daily goals, or completion status
- **Quick Actions:** Enable core actions directly from the widget
- **Motivational Content:** Display achievements, quotes, or progress celebrations
- **Smart Reminders:** Contextual prompts based on user behavior

**Design Principles:**
- Keep widgets simple and focused on core value proposition
- Update content dynamically to maintain relevance
- Use clear, readable fonts and high-contrast colors
- Optimize for different widget sizes and orientations

**Implementation Strategy:**
- Start with a simple progress/streak widget
- Gradually add functionality based on user feedback
- A/B test different widget designs and content
- Monitor widget usage analytics to optimize engagement

## Advanced Retention Techniques

### Personalization and AI-Driven Engagement

**Personalized Experiences:**
- Adaptive difficulty based on skill level
- Customized content recommendations
- Personalized notification timing and content
- Dynamic user interface adaptation

**Machine Learning Applications:**
- Predict user churn risk for proactive intervention
- Optimize push notification timing and content
- Personalize in-app recommendations
- Dynamic pricing and offer optimization

### Community and Social Features

**Social Engagement Elements:**
- Friend systems and social connections
- Guild or team-based activities
- User-generated content sharing
- Social challenges and competitions

**Community Building:**
- Forums or chat systems
- User events and tournaments
- Beta testing communities
- Influencer and creator programs

### Onboarding Optimization

**First-Time User Experience:**
- Progressive disclosure of features
- Interactive tutorials that demonstrate value
- Personalized setup based on user preferences
- Quick wins to establish early success

**Onboarding Metrics to Track:**
- Tutorial completion rates
- Time to first meaningful action
- Feature adoption during onboarding
- Correlation between onboarding completion and retention

## Measuring Success: KPIs and Dashboards

### Essential Dashboard Components

**Real-Time Metrics:**
- Current DAU/MAU numbers
- Real-time user sessions
- Push notification open rates
- Revenue metrics (for monetized apps)

**Trend Analysis:**
- Weekly and monthly retention cohorts
- User acquisition funnel performance
- Feature adoption rates over time
- Customer satisfaction scores (if applicable)

**Predictive Analytics:**
- Churn risk scoring
- LTV predictions
- User segmentation for targeted campaigns
- A/B test performance tracking

### Setting Up Effective Analytics

**Tool Selection:**
- **Firebase Analytics** for comprehensive mobile app analytics
- **Amplitude** for advanced user behavior analysis
- **Mixpanel** for detailed event tracking and funnels
- **AppsFlyer** for attribution and marketing analytics

**Event Tracking Strategy:**
- Define core events that indicate engagement
- Track user actions throughout the app journey
- Implement proper event naming conventions
- Ensure data quality through regular audits

## Future-Proofing Your Analytics Strategy

### Privacy-First Analytics

With increasing privacy regulations and platform changes:
- Implement first-party data collection strategies
- Focus on aggregated insights rather than individual tracking
- Ensure GDPR and CCPA compliance
- Build user trust through transparent data practices

### Emerging Technologies

**AI and Machine Learning:**
- Automated anomaly detection in user behavior
- Predictive analytics for user lifetime value
- Dynamic personalization engines
- Intelligent notification optimization

**Cross-Platform Analytics:**
- Unified user tracking across devices
- Cross-platform retention analysis
- Omnichannel user experience optimization

## Taking Action: Implementation Roadmap

### Phase 1: Foundation (Weeks 1-4)
1. Implement core metrics tracking (DAU, MAU, retention)
2. Set up basic cohort analysis
3. Establish baseline measurements
4. Create initial dashboard and reporting

### Phase 2: Optimization (Weeks 5-12)
1. Implement gamification elements
2. Launch daily bonus system
3. Optimize push notification strategy
4. A/B test key features and messaging

### Phase 3: Advanced Analytics (Weeks 13-24)
1. Deploy predictive churn models
2. Implement advanced personalization
3. Launch community features
4. Optimize user acquisition based on LTV data

## Partner with Data Experts

Building a comprehensive data analytics infrastructure for mobile games and apps requires specialized expertise in data engineering, analytics implementation, and strategic optimization.

**Our Data Pipeline and Analytics Services:**

At Bitscorp, we specialize in setting up robust data pipelines and comprehensive analytics solutions for mobile games and applications. Our team of data engineers and analysts can help you:

- **Custom Analytics Implementation:** Tailored tracking solutions that capture the metrics most critical to your app's success
- **Data Pipeline Architecture:** Scalable, real-time data processing systems that grow with your user base
- **Advanced User Segmentation:** Sophisticated audience analysis to optimize retention and monetization strategies
- **Predictive Analytics Models:** Machine learning solutions for churn prediction, LTV forecasting, and personalization
- **Dashboard and Reporting Systems:** Beautiful, actionable dashboards that provide insights at a glance
- **A/B Testing Infrastructure:** Statistical rigor in testing and optimization to maximize your retention improvements

Whether you're launching a new mobile game, scaling an existing app, or looking to optimize your current analytics setup, our team brings the expertise to transform your data into actionable insights that drive user engagement and business growth.

**Ready to unlock the full potential of your mobile app's data?** Contact Bitscorp today to discuss how we can build a custom analytics solution that drives measurable improvements in user retention and engagement.

**Let's turn your data into your competitive advantage.**

Discover how Luigi makes data pipeline orchestration effortless with tree-like task dependencies, built-in extensions for Hive, S3, Spark, and robust Python examples for enterprise data workflows.

Luigi Data Pipelines: Simplifying Python Workflow Orchestration

---
title: "Luigi Data Pipelines: Simplifying Python Workflow Orchestration"
date: "2025-07-22"
description: "Discover how Luigi makes data pipeline orchestration effortless with tree-like task dependencies, built-in extensions for Hive, S3, Spark, and robust Python examples for enterprise data workflows."
slug: "luigi-data-pipelines-python-workflow-orchestration"
tags: "#luigi #python #datapipelines #etl #spark #hive #s3 #dataengineering"
---

# Luigi Data Pipelines: Simplifying Python Workflow Orchestration

At Bitscorp, we've implemented numerous data pipeline solutions for our enterprise clients, and Luigi has consistently proven to be one of the most reliable and intuitive workflow orchestration tools available. In this comprehensive guide, we'll explore why Luigi stands out, how to implement it effectively, and the powerful extensions that make it enterprise-ready.

## Why We Choose Luigi for Data Pipelines

Luigi, developed by Spotify, addresses the fundamental challenges of data workflow orchestration with an elegant, Python-native approach. Here's why it's become our go-to solution:

### 1. **Declarative Task Dependencies**
Luigi's tree-like task structure makes complex workflows intuitive to design and maintain. Dependencies are explicitly declared, making pipeline logic transparent and debuggable.

### 2. **Failure Recovery**
Built-in failure handling and task retry mechanisms ensure robust data processing even in unstable environments.

### 3. **Incremental Processing**
Luigi's task completion tracking prevents unnecessary recomputation, making it ideal for large-scale data processing.

### 4. **Rich Ecosystem**
Extensive library of extensions for popular data platforms like Hadoop, Spark, AWS S3, and more.

## Core Luigi Concepts: requires(), run(), and output()

Every Luigi task follows a simple contract with three key methods:

### Basic Task Structure

```python
import luigi
import pandas as pd
from datetime import datetime, date

class ExtractCustomerData(luigi.Task):
    """Extract customer data from source database"""
    
    date_param = luigi.DateParameter(default=date.today())
    
    def requires(self):
        """Define task dependencies - what must complete before this task"""
        return []  # No dependencies for this initial extraction
    
    def output(self):
        """Define task output - how Luigi tracks completion"""
        return luigi.LocalTarget(f'data/customers_{self.date_param}.csv')
    
    def run(self):
        """The actual task logic"""
        # Simulate database extraction
        customers_data = {
            'customer_id': range(1, 1001),
            'name': [f'Customer_{i}' for i in range(1, 1001)],
            'signup_date': [self.date_param] * 1000,
            'lifetime_value': [100 + (i * 10) % 500 for i in range(1, 1001)]
        }
        
        df = pd.DataFrame(customers_data)
        
        # Write to output target
        with self.output().open('w') as output_file:
            df.to_csv(output_file, index=False)
```

## Building Complex Pipeline Trees

Luigi's strength lies in creating interconnected task dependencies. Here's a real-world example of a customer analytics pipeline:

```python
class TransformCustomerData(luigi.Task):
    """Transform and clean customer data"""
    
    date_param = luigi.DateParameter(default=date.today())
    
    def requires(self):
        """This task depends on raw customer data"""
        return ExtractCustomerData(date_param=self.date_param)
    
    def output(self):
        return luigi.LocalTarget(f'data/transformed_customers_{self.date_param}.csv')
    
    def run(self):
        # Read input from dependency
        input_df = pd.read_csv(self.input().open('r'))
        
        # Apply transformations
        input_df['customer_tier'] = pd.cut(
            input_df['lifetime_value'], 
            bins=[0, 200, 500, float('inf')], 
            labels=['Bronze', 'Silver', 'Gold']
        )
        
        input_df['days_since_signup'] = (
            pd.to_datetime('today') - pd.to_datetime(input_df['signup_date'])
        ).dt.days
        
        # Write transformed data
        with self.output().open('w') as output_file:
            input_df.to_csv(output_file, index=False)

class GenerateCustomerReport(luigi.Task):
    """Generate final customer analytics report"""
    
    date_param = luigi.DateParameter(default=date.today())
    
    def requires(self):
        """Depends on transformed data"""
        return TransformCustomerData(date_param=self.date_param)
    
    def output(self):
        return luigi.LocalTarget(f'reports/customer_report_{self.date_param}.json')
    
    def run(self):
        # Read transformed data
        df = pd.read_csv(self.input().open('r'))
        
        # Generate analytics
        report = {
            'date': str(self.date_param),
            'total_customers': len(df),
            'tier_distribution': df['customer_tier'].value_counts().to_dict(),
            'average_lifetime_value': df['lifetime_value'].mean(),
            'avg_days_since_signup': df['days_since_signup'].mean()
        }
        
        # Write report
        with self.output().open('w') as output_file:
            import json
            json.dump(report, output_file, indent=2)
```

## Advanced Pipeline Patterns

### Dynamic Task Generation

```python
class ProcessMultipleDataSources(luigi.Task):
    """Process data from multiple sources dynamically"""
    
    sources = luigi.ListParameter(default=['source_a', 'source_b', 'source_c'])
    date_param = luigi.DateParameter(default=date.today())
    
    def requires(self):
        """Generate tasks for each data source"""
        return [
            ProcessDataSource(source=source, date_param=self.date_param) 
            for source in self.sources
        ]
    
    def output(self):
        return luigi.LocalTarget(f'data/consolidated_{self.date_param}.csv')
    
    def run(self):
        # Combine all input files
        combined_data = []
        
        for input_target in self.input():
            df = pd.read_csv(input_target.open('r'))
            combined_data.append(df)
        
        final_df = pd.concat(combined_data, ignore_index=True)
        
        with self.output().open('w') as output_file:
            final_df.to_csv(output_file, index=False)

class ProcessDataSource(luigi.Task):
    """Process individual data source"""
    
    source = luigi.Parameter()
    date_param = luigi.DateParameter()
    
    def output(self):
        return luigi.LocalTarget(f'data/{self.source}_{self.date_param}.csv')
    
    def run(self):
        # Simulate source-specific processing
        data = {
            'source': [self.source] * 100,
            'value': range(100),
            'processed_date': [self.date_param] * 100
        }
        
        df = pd.DataFrame(data)
        
        with self.output().open('w') as output_file:
            df.to_csv(output_file, index=False)
```

## Luigi Extensions: Enterprise-Ready Integrations

Luigi's ecosystem includes powerful extensions for enterprise data platforms:

### 1. **Luigi Spark Integration**

```python
import luigi
from luigi.contrib.spark import SparkSubmitTask, PySparkTask

class SparkDataProcessing(PySparkTask):
    """Run Spark job for large-scale data processing"""
    
    date = luigi.DateParameter()
    
    def requires(self):
        return ExtractCustomerData(date_param=self.date)
    
    def output(self):
        return luigi.LocalTarget(f'spark_output/processed_{self.date}')
    
    def main(self, sc, *args):
        """PySpark job logic"""
        # Read input data
        input_rdd = sc.textFile(self.input().path)
        
        # Process with Spark
        processed_rdd = input_rdd.map(lambda line: line.upper())
        
        # Save results
        processed_rdd.saveAsTextFile(self.output().path)
```

### 2. **AWS S3 Integration**

```python
from luigi.contrib.s3 import S3Target, S3Task
import boto3

class UploadToS3(luigi.Task):
    """Upload processed data to S3"""
    
    date_param = luigi.DateParameter()
    bucket = luigi.Parameter(default='my-data-bucket')
    
    def requires(self):
        return GenerateCustomerReport(date_param=self.date_param)
    
    def output(self):
        return S3Target(f's3://{self.bucket}/reports/customer_report_{self.date_param}.json')
    
    def run(self):
        # Read local file and upload to S3
        with self.input().open('r') as input_file:
            with self.output().open('w') as s3_file:
                s3_file.write(input_file.read())

class S3DataExtraction(S3Task):
    """Extract data directly from S3"""
    
    date_param = luigi.DateParameter()
    source_bucket = luigi.Parameter(default='source-data-bucket')
    
    def output(self):
        return S3Target(f's3://{self.source_bucket}/raw_data_{self.date_param}.csv')
    
    def run(self):
        # S3-specific data extraction logic
        pass
```

### 3. **Hadoop Hive Integration**

```python
from luigi.contrib.hive import HiveQueryTask, HiveTableTarget

class HiveDataAggregation(HiveQueryTask):
    """Run Hive queries for data aggregation"""
    
    date_param = luigi.DateParameter()
    
    def query(self):
        return f"""
        INSERT OVERWRITE TABLE customer_summary_${{{self.date_param}}}
        SELECT 
            customer_tier,
            COUNT(*) as customer_count,
            AVG(lifetime_value) as avg_ltv,
            MIN(signup_date) as earliest_signup,
            MAX(signup_date) as latest_signup
        FROM customers 
        WHERE date_partition = '{self.date_param}'
        GROUP BY customer_tier
        """
    
    def output(self):
        return HiveTableTarget(
            table=f'customer_summary_{self.date_param}',
            database='analytics'
        )
```

### 4. **PostgreSQL Integration**

```python
from luigi.contrib.postgres import PostgresQuery, CopyToTable
import pandas as pd

class LoadCustomersToPostgres(CopyToTable):
    """Load processed customer data to PostgreSQL"""
    
    date_param = luigi.DateParameter()
    
    host = luigi.Parameter(default='localhost')
    database = luigi.Parameter(default='analytics')
    user = luigi.Parameter(default='luigi_user')
    password = luigi.Parameter(default='password')
    table = luigi.Parameter(default='customer_analytics')
    
    def requires(self):
        return TransformCustomerData(date_param=self.date_param)
    
    def columns(self):
        return [
            ('customer_id', 'INT'),
            ('name', 'VARCHAR(255)'),
            ('signup_date', 'DATE'),
            ('lifetime_value', 'DECIMAL(10,2)'),
            ('customer_tier', 'VARCHAR(50)'),
            ('days_since_signup', 'INT')
        ]
    
    def rows(self):
        """Read data and yield rows for insertion"""
        df = pd.read_csv(self.input().open('r'))
        
        for _, row in df.iterrows():
            yield (
                row['customer_id'],
                row['name'],
                row['signup_date'],
                row['lifetime_value'],
                row['customer_tier'],
                row['days_since_signup']
            )
```

## Running Luigi Pipelines

### Command Line Execution

```bash
# Run a specific task
python -m luigi --module customer_pipeline GenerateCustomerReport --date-param 2025-07-22

# Run with Luigi scheduler daemon
luigid  # Start scheduler in background

# Run with web UI
python -m luigi --module customer_pipeline GenerateCustomerReport --date-param 2025-07-22 --scheduler-host localhost
```

### Configuration File (luigi.cfg)

```ini
[core]
logging_conf_file = logging.conf
no_configure_logging = True

[task_history]
db_connection = sqlite:///luigi_history.db

[postgres]
host = localhost
database = analytics
user = luigi_user
password = secure_password

[spark]
spark_home = /opt/spark
master = local[*]
deploy_mode = client
```

## Monitoring and Web Interface

Luigi provides an excellent web interface for monitoring pipeline execution:

```python
# Start Luigi central scheduler with web UI
# Visit http://localhost:8082 to see:
# - Task dependency graphs
# - Execution status
# - Error logs
# - Resource utilization
# - Historical runs
```

## Best Practices We Follow at Bitscorp

### 1. **Idempotent Tasks**
```python
class IdempotentDataProcessing(luigi.Task):
    def run(self):
        # Always write to a temp file first
        temp_output = luigi.LocalTarget(self.output().path + '.tmp')
        
        with temp_output.open('w') as f:
            # Do processing
            pass
        
        # Atomic move to final location
        temp_output.move(self.output())
```

### 2. **Parameter Validation**
```python
class ValidatedTask(luigi.Task):
    start_date = luigi.DateParameter()
    end_date = luigi.DateParameter()
    
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        
        if self.start_date >= self.end_date:
            raise ValueError("start_date must be before end_date")
```

### 3. **Resource Management**
```python
class ResourceManagedTask(luigi.Task):
    def requires_resources(self):
        # Limit concurrent database connections
        return {'database_connections': 1}
    
    def run(self):
        # Task will wait for resource availability
        pass
```

## Advanced Luigi Extensions Available

Luigi's ecosystem extends far beyond basic functionality:

- **luigi-docker**: Run tasks in Docker containers
- **luigi-kubernetes**: Deploy Luigi tasks on Kubernetes
- **luigi-bigquery**: Google BigQuery integration
- **luigi-redshift**: Amazon Redshift support
- **luigi-salesforce**: Salesforce data extraction
- **luigi-elasticsearch**: Elasticsearch indexing
- **luigi-ftp**: FTP file operations
- **luigi-hdfs**: Hadoop Distributed File System support

## Conclusion

Luigi has proven invaluable in our data engineering projects at Bitscorp. Its Python-native approach, robust dependency management, and extensive ecosystem make it ideal for enterprise data pipelines. The clear separation of concerns through `requires()`, `run()`, and `output()` methods creates maintainable, testable workflows that scale with your data needs.

Whether you're building simple ETL processes or complex multi-stage analytics pipelines, Luigi provides the foundation for reliable, monitorable data workflows. Its integration with popular big data tools like Spark, Hive, and cloud platforms makes it a comprehensive solution for modern data engineering challenges.

For enterprises looking to implement robust data pipeline orchestration, Luigi offers the perfect balance of simplicity, power, and reliability that we've come to depend on in our client projects.

Learn how we revolutionized a hotel chain's customer service with an intelligent bot system using n8n workflows, OpenAI O3, and multi-platform integration across Telegram and WhatsApp.

Transforming Hotel Customer Service with AI: A Complete Bot Solution Using n8n and OpenAI

---
title: "Transforming Hotel Customer Service with AI: A Complete Bot Solution Using n8n and OpenAI"
date: "2025-07-11"
description: "Learn how we revolutionized a hotel chain's customer service with an intelligent bot system using n8n workflows, OpenAI O3, and multi-platform integration across Telegram and WhatsApp."
slug: "ai-hotel-bot-n8n-transformation"
tags: "#n8n #openai #hotel #telegram #whatsapp #automation #customerservice #ai"
---

# Transforming Hotel Customer Service with AI: A Complete Bot Solution Using n8n and OpenAI

The hospitality industry thrives on exceptional customer service, but providing 24/7 support while managing costs remains a persistent challenge. At Bitscorp, we recently transformed a boutique hotel chain's operations by developing an intelligent customer service bot that handles everything from room inquiries to emergency escalations—all while enhancing rather than replacing human interaction.

## The Challenge: Modern Hospitality Pain Points

Our client, a rapidly growing boutique hotel chain, faced the universal hospitality dilemma:

**Around-the-Clock Demands**: Guests expect instant responses regardless of time zones or staff availability.

**Repetitive Inquiries**: 70% of customer questions were about amenities, directions, policies, and booking procedures.

**Channel Fragmentation**: Customers contacted them via phone, email, social media, and messaging apps, creating inconsistent experiences.

**Staff Burnout**: Front desk employees spent most of their time answering the same questions instead of creating memorable guest experiences.

**Lost Revenue**: Delayed responses led to abandoned bookings and frustrated potential guests choosing competitors.

## The Solution: Intelligent Automation with Human Touch

We designed a comprehensive AI-powered customer service ecosystem that seamlessly blends automation with human expertise.

### Technical Architecture Overview

**Core Technologies**:
- **n8n**: Visual workflow orchestration for complex decision trees
- **OpenAI O3**: Cost-effective AI model for natural language understanding
- **Telegram & WhatsApp APIs**: Multi-platform customer engagement
- **Knowledge Base**: Comprehensive hotel information repository
- **Booking System Integration**: Direct connection to reservation platform

### Building the Knowledge Foundation

The bot's intelligence starts with a meticulously crafted knowledge base containing:

**Property Information**:
- Detailed room descriptions with amenities
- High-quality room photos for instant sharing
- Facility information (pool, gym, restaurant hours)
- Local attraction recommendations

**Operational Data**:
- Check-in/check-out procedures
- Pricing structures and special offers
- Pet policies and accessibility features
- Emergency protocols and contacts

**Location Intelligence**:
- Precise driving directions from major landmarks
- Public transportation options
- Nearby restaurants and attractions
- Parking information and costs

### n8n Workflow Orchestration: The Brain of Operations

n8n's visual workflow builder proved perfect for managing complex customer service logic. Here's how we structured the decision flow:

```javascript
// Core n8n workflow logic
function processCustomerQuery(message, customer_data) {
  // Step 1: Analyze intent and urgency
  const intent = analyzeIntent(message);
  const urgency = assessUrgency(message, customer_data);

  // Step 2: Route based on intent and urgency
  if (urgency === 'CRITICAL') {
    notifyManager(customer_data, message);
    escalateToHuman();
    return "Emergency escalation initiated";
  }

  if (intent === 'BOOKING') {
    return redirectToBookingSystem(customer_data);
  }

  if (intent === 'DIRECTIONS') {
    return sendLocationAndDirections(customer_data.location);
  }

  if (intent === 'ROOM_INFO') {
    return sendRoomPhotosAndDetails(intent.room_type);
  }

  // Default: AI-powered response
  return generateAIResponse(message, knowledgeBase);
}
```

### OpenAI O3: The Cost-Effective Intelligence Engine

We chose OpenAI's O3 model for its optimal balance of capability and cost-effectiveness:

**Natural Language Understanding**: Accurately interprets customer intent across multiple languages and communication styles.

**Context Awareness**: Maintains conversation context to provide relevant follow-up responses.

**Sentiment Analysis**: Detects frustrated or urgent customers for appropriate escalation.

**Knowledge Integration**: Seamlessly accesses and presents information from the hotel's knowledge base.

### Multi-Platform Integration: Meeting Customers Where They Are

**Telegram Integration**:
- Rich media support for room photos and location sharing
- Inline keyboard navigation for easy option selection
- Bot commands for quick access to common information

**WhatsApp Business Integration**:
- Familiar interface for international guests
- Voice message support for complex inquiries
- Status updates for booking confirmations

### Intelligent Decision Making

The bot's intelligence shines in its decision-making capabilities:

#### Escalation Logic
```javascript
function shouldEscalate(message, customerHistory) {
  const urgencyIndicators = [
    'emergency', 'urgent', 'complaint', 'problem',
    'broken', 'not working', 'unhappy', 'refund'
  ];

  const isUrgent = urgencyIndicators.some(word =>
    message.toLowerCase().includes(word)
  );

  const isRepeatCustomer = customerHistory.interactions > 3;
  const hasRecentComplaint = customerHistory.lastComplaint < 24; // hours

  return isUrgent || (isRepeatCustomer && hasRecentComplaint);
}
```

#### Booking Integration
```javascript
function handleBookingInquiry(customerData, dates, roomType) {
  // Check availability in real-time
  const availability = checkAvailability(dates, roomType);

  if (availability.hasRooms) {
    return {
      action: 'redirect_to_booking',
      message: generateBookingLink(customerData, dates, roomType),
      rooms: availability.rooms
    };
  } else {
    return {
      action: 'suggest_alternatives',
      alternatives: suggestAlternativeDates(dates, roomType)
    };
  }
}
```

## Real-World Implementation Stories

### Case Study 1: The Lost Guest

A guest messaged at 11 PM: "I'm lost trying to find your hotel. GPS isn't working properly."

**Bot Response**:
1. Instantly identified location-based intent
2. Sent precise driving directions with landmarks
3. Shared hotel location pin
4. Provided front desk direct contact for real-time assistance
5. Followed up 30 minutes later to ensure safe arrival

**Outcome**: Guest arrived safely and later praised the immediate, helpful response in their review.

### Case Study 2: The Emergency Escalation

A guest reported: "The air conditioning in room 302 isn't working and it's very hot."

**Bot Intelligence**:
1. Detected urgency keywords and room number
2. Immediately notified night manager via SMS
3. Escalated to human staff within 2 minutes
4. Logged the issue in maintenance system
5. Followed up next day to ensure resolution

**Outcome**: Maintenance resolved the issue within 15 minutes, preventing a negative review and demonstrating proactive service.

### Case Study 3: The International Booking

A Spanish-speaking guest inquired about weekend availability.

**Bot Capabilities**:
1. Detected Spanish language and responded accordingly
2. Checked real-time availability for requested dates
3. Showed room photos with Spanish descriptions
4. Provided direct booking link with pre-filled guest information
5. Offered local restaurant recommendations in Spanish

**Outcome**: Completed booking within 10 minutes, generating €450 in revenue from a previously unreachable market segment.

## Business Impact: Transformation by the Numbers

### Customer Experience Metrics

**Response Time**: Average response time decreased from 45 minutes to 3 seconds for standard inquiries.

**Customer Satisfaction**: CSAT scores increased from 7.2 to 9.1 out of 10.

**Resolution Rate**: 89% of customer inquiries resolved without human intervention.

**Multilingual Support**: Now serving customers in 12 languages automatically.

### Operational Efficiency

**Staff Productivity**: Front desk staff productivity increased 60%, focusing on high-value guest interactions.

**Cost Reduction**: Customer service costs reduced by 45% while improving service quality.

**24/7 Availability**: True round-the-clock service without additional staffing costs.

**Booking Conversion**: Direct booking rate increased 35% through seamless bot-to-booking integration.

### Revenue Impact

**Increased Bookings**: 28% increase in direct bookings through improved customer experience.

**Reduced Abandonment**: Booking abandonment rate decreased 52% due to instant query resolution.

**Upselling Opportunities**: Bot identifies and promotes relevant upgrades, increasing average booking value 15%.

## Technical Excellence: Why This Stack Works

### n8n Advantages

**Visual Development**: Complex workflows designed graphically, making modifications intuitive for non-technical staff.

**Integration Ecosystem**: Native connectors for major platforms eliminate custom API development.

**Scalability**: Easily handles peak seasons and sudden traffic spikes.

**Maintenance**: Visual workflows are easy to understand, modify, and troubleshoot.

### OpenAI O3 Benefits

**Cost Optimization**: Delivers sophisticated AI capabilities at a fraction of premium model costs.

**Multilingual Support**: Native language understanding across dozens of languages.

**Contextual Intelligence**: Maintains conversation flow and understands implied meanings.

**Rapid Deployment**: No model training required—instant deployment with prompt engineering.

### Multi-Platform Strategy

**Customer Choice**: Guests use their preferred communication platform.

**Unified Experience**: Consistent service quality across all channels.

**Rich Media**: Platform-specific features like photos, locations, and quick replies.

## Lessons Learned and Best Practices

### Knowledge Base Curation

**Regular Updates**: Monthly review and update of hotel information and local recommendations.

**Staff Input**: Front desk team contributes common questions and effective responses.

**Guest Feedback**: Customer interactions inform knowledge base improvements.

### Escalation Design

**Clear Triggers**: Well-defined criteria for human handoff prevent customer frustration.

**Context Preservation**: Complete conversation history transfers to human agents.

**Follow-up Automation**: Automated check-ins ensure issue resolution.

### Performance Monitoring

**Analytics Dashboard**: Real-time monitoring of bot performance and customer satisfaction.

**Continuous Learning**: Regular analysis of unresolved queries to improve bot capabilities.

**A/B Testing**: Systematic testing of response variations to optimize effectiveness.

## Future Enhancements

**Voice Integration**: Adding voice message processing for more natural interactions.

**Predictive Analytics**: Anticipating guest needs based on booking patterns and preferences.

**IoT Integration**: Connecting with room systems for real-time status updates.

**Personalization Engine**: Customized recommendations based on guest history and preferences.

## Getting Started: Implementation Roadmap

### Phase 1: Foundation (Week 1-2)
- Knowledge base creation and curation
- n8n workflow design and testing
- OpenAI integration and prompt optimization

### Phase 2: Platform Integration (Week 3-4)
- Telegram and WhatsApp bot deployment
- Booking system API integration
- Emergency notification setup

### Phase 3: Testing and Refinement (Week 5-6)
- Comprehensive testing with real scenarios
- Staff training on escalation procedures
- Fine-tuning based on initial feedback

### Phase 4: Launch and Optimization (Week 7+)
- Gradual rollout to guest interactions
- Performance monitoring and adjustments
- Continuous improvement based on analytics

## Conclusion: The Future of Hospitality Customer Service

This project demonstrates how thoughtful AI implementation can enhance rather than replace human service. By automating routine inquiries, our hotel bot frees staff to create memorable experiences while ensuring guests receive instant, accurate assistance around the clock.

The combination of n8n's workflow orchestration, OpenAI's cost-effective intelligence, and multi-platform integration creates a scalable solution that grows with the business. Most importantly, it improves both guest satisfaction and staff productivity—a rare win-win in technology implementation.

The hospitality industry's future lies not in choosing between human service and automation, but in intelligently combining both to create experiences that exceed guest expectations while optimizing operational efficiency.

*Ready to transform your customer service? Start with a comprehensive knowledge base, design intelligent workflows in n8n, and let AI handle the routine while your team focuses on creating unforgettable experiences.*

Discover how we automated stock market analysis using Claude AI for data gathering and DuckDB for lightning-fast analytics. Learn about our Python-powered pipeline for daily financial intelligence.

AI-Powered Stock Analysis with DuckDB and Claude: Automating Financial Data Intelligence

---
title: "AI-Powered Stock Analysis with DuckDB and Claude: Automating Financial Data Intelligence"
date: "2025-07-01"
description: "Discover how we automated stock market analysis using Claude AI for data gathering and DuckDB for lightning-fast analytics. Learn about our Python-powered pipeline for daily financial intelligence."
slug: "ai-powered-stock-analysis-duckdb"
tags: "#duckdb #claude #ai #stocks #python #analytics #automation"
---

# AI-Powered Stock Analysis with DuckDB and Claude: Automating Financial Data Intelligence

At Bitscorp, we've revolutionized our approach to financial data analysis by combining Claude AI's research capabilities with DuckDB's blazing-fast analytics engine. Our automated pipeline gathers, processes, and analyzes stock market data daily, providing actionable insights through an elegant Python-powered workflow.

## The Challenge: Information Overload in Financial Markets

Financial markets generate massive amounts of data every second. Traditional approaches to stock analysis often involve:
- Manual research across multiple sources
- Complex database setups for data storage
- Slow query performance on large datasets
- Time-intensive data preparation workflows

We needed a solution that could automate data gathering while providing lightning-fast analytics capabilities.

## Our Solution: Claude + DuckDB + Python

### Claude AI: The Research Powerhouse

Claude's research mode has proven exceptionally effective for gathering comprehensive stock information. Here's why Claude excels at financial data collection:

**Speed and Accuracy**: Claude processes multiple financial sources simultaneously, extracting relevant metrics, news sentiment, and fundamental analysis in seconds rather than hours.

**Structured Output**: We prompt Claude to format stock data directly into CSV format, eliminating manual data transformation steps.

**Research Mode Excellence**: Claude's research capabilities allow it to cross-reference multiple sources, providing comprehensive company analysis including financial ratios, recent news impact, and market sentiment.

**Real-time Insights**: Claude can analyze breaking news, earnings reports, and market movements as they happen, providing context that pure numerical data cannot capture.

### DuckDB: The Analytics Beast

DuckDB has become our go-to choice for financial data analytics, and here's why it's absolutely awesome:

**Single Binary Simplicity**: Installing DuckDB requires just one binary file—no complex database server setup, no configuration files, no administrative overhead. You download it, run it, and you're analyzing data.

**Blazing Performance**: DuckDB's columnar storage and vectorized execution engine make it incredibly fast for analytical queries. Complex aggregations across millions of stock records complete in milliseconds.

**SQL Compatibility**: Full PostgreSQL-compatible SQL syntax means our team can leverage existing SQL knowledge without learning new query languages.

**Python Integration**: Native Python integration allows seamless data flow from our Claude-powered collection scripts directly into analytics workflows.

**CSV Superpowers**: DuckDB can query CSV files directly without importing—perfect for our daily stock data files from Claude.

**Advanced Analytics**: Built-in support for window functions, complex aggregations, and statistical functions makes sophisticated financial analysis straightforward.

## The Automated Workflow

### Daily Data Collection

Our Python script orchestrates the entire pipeline:

```python
# Simplified workflow overview
def daily_stock_analysis():
    # 1. Claude gathers stock data
    stock_data = claude_research_stocks(watchlist)

    # 2. Save to CSV with timestamp
    save_to_csv(stock_data, f"stocks_{today}.csv")

    # 3. DuckDB analytics
    insights = analyze_with_duckdb(stock_data)

    # 4. Generate reports
    generate_daily_report(insights)
```

### Claude's Research Process

We've fine-tuned our prompts to make Claude an exceptional financial researcher:

1. **Multi-Source Analysis**: Claude examines financial statements, recent news, analyst reports, and market sentiment
2. **Structured Data Extraction**: Outputs consistent CSV format with standardized columns for price data, ratios, and qualitative assessments
3. **Contextual Intelligence**: Provides reasoning for stock movements and identifies potential catalysts

### DuckDB Analytics Magic

Once Claude delivers the CSV data, DuckDB takes over for analysis:

```sql
-- Example: Identify trending stocks with high momentum
SELECT
    symbol,
    company_name,
    price_change_percent,
    volume_ratio,
    sentiment_score,
    ROW_NUMBER() OVER (ORDER BY momentum_score DESC) as rank
FROM daily_stocks
WHERE date = '2025-01-20'
    AND momentum_score > 0.7
ORDER BY momentum_score DESC;
```

### Automation Benefits

**Zero Manual Intervention**: The entire pipeline runs automatically via cron jobs, collecting and analyzing data while we sleep.

**Consistent Data Quality**: Claude's structured prompts ensure consistent data format across all collection runs.

**Scalable Architecture**: Adding new stocks to our watchlist requires only updating a configuration file.

**Cost Effective**: No expensive Bloomberg terminals or premium data feeds—Claude accesses publicly available information intelligently.

## Why This Stack Works

### DuckDB Advantages for Financial Data

- **No Database Administration**: Focus on analysis, not database maintenance
- **Instant Deployment**: One binary file deployment across any environment
- **Memory Efficiency**: Handles large datasets efficiently on modest hardware
- **Export Flexibility**: Easy integration with visualization tools and reporting systems

### Claude's Financial Intelligence

- **Comprehensive Research**: Synthesizes information from multiple sources automatically
- **Natural Language Processing**: Understands financial jargon and market context
- **Rapid Information Processing**: Analyzes multiple stocks simultaneously
- **Adaptable Prompting**: Easily modify research focus based on market conditions

### Python Orchestration

- **Ecosystem Integration**: Seamless integration with both Claude API and DuckDB
- **Scheduling Flexibility**: Easy automation with cron jobs or task schedulers
- **Error Handling**: Robust retry mechanisms for API calls and data processing
- **Extensibility**: Simple to add new data sources or analysis methods

## Real-World Impact

Our automated system has transformed our investment research process:

- **Time Savings**: What previously took hours of manual research now completes in minutes
- **Data Consistency**: Standardized data collection eliminates human error
- **Comprehensive Coverage**: Monitor hundreds of stocks simultaneously
- **Actionable Insights**: DuckDB's fast queries enable real-time decision making

## Getting Started

The beauty of this stack lies in its simplicity:

1. **Install DuckDB**: Download one binary file
2. **Set up Claude API**: Simple API key configuration
3. **Write Python glue**: Basic scripts to orchestrate the workflow
4. **Start Analyzing**: Begin with a small watchlist and expand

This approach democratizes sophisticated financial analysis, making institutional-grade research capabilities accessible to individual investors and small teams.


*Ready to automate your financial research? Start with DuckDB's single binary, connect to Claude's research capabilities, and let Python orchestrate your path to data-driven investment decisions.*

Learn our proven workflow for rapid application development using Claude Code for prototyping, followed by Cursor for refinement. Case study: Brawl Stars gameplay streaming app.

Rapid App Prototyping with Claude Code: From Idea to Store-Ready

---
title: "Rapid App Prototyping with Claude Code: From Idea to Store-Ready"
date: "2025-06-24"
description: "Learn our proven workflow for rapid application development using Claude Code for prototyping, followed by Cursor for refinement. Case study: Brawl Stars gameplay streaming app."
slug: "rapid-prototyping-claude-code-workflow"
tags: "#claudecode #prototyping #ios #swift #ai #development"
---

# Rapid App Prototyping with Claude Code: From Idea to Store-Ready

At Bitscorp, we've revolutionized our development process by leveraging AI tools for rapid application prototyping. Our workflow combines Claude Code's intelligent code generation with Cursor's refinement capabilities to go from concept to store-ready applications in record time.

## Current Project: Brawl Stars Gameplay Streaming App

We're currently developing an iOS application for streaming Brawl Stars gameplay, set to launch in August 2025. This project perfectly demonstrates our streamlined AI-powered development workflow.

## The 5-Phase Development Workflow

### Phase 1: Foundation with Claude Code

**Project Initialization**: We start by asking Claude Code to create the entire Xcode project structure, including proper Swift configurations and iOS deployment settings.

**Architecture Planning**: The magic happens when we provide Claude Code with a detailed prompt describing our app concept. It generates a comprehensive base plan including:
- Core streaming functionality architecture
- UI component structure
- Data flow patterns
- Integration points for gameplay capture

**Swift Implementation**: Claude Code handles the heavy lifting of implementing core features, from camera integration to streaming protocols, generating clean, maintainable Swift code.

### Phase 2: Refinement with Cursor

**Code Polish**: We transition to Cursor for meticulous step-by-step refinement, ensuring every component meets production standards.

**Testing & Debugging**: Making the application fully runnable involves comprehensive testing, proper error handling, and performance optimization.

**iOS-Specific Optimizations**: Fine-tuning streaming performance, memory management, and ensuring smooth gameplay capture without affecting game performance.

### Phase 3: Visual Identity

**Competitive Analysis**: Before creating assets, we analyze competitor app icons to understand market expectations and design trends.

**AI-Powered Icon Generation**: We use ChatGPT for icon design, but the key is crafting detailed prompts that specify style, color schemes, and brand alignment. This requires careful prompt preparation to ensure consistent results across different icon sizes and platforms.

### Phase 4: Global Market Preparation

**Multi-Language Support**: Claude Code excels at translating app descriptions and metadata into 10+ languages, maintaining context and marketing appeal across cultures.

**Store Asset Organization**: We create separate folders containing optimized descriptions for App Store and Google Play, each tailored to platform-specific requirements and character limits.

**Screenshot Workflow**: Using iOS Simulator, we capture key app screens, then design compelling store screenshots in Figma that highlight core features and user benefits.

### Phase 5: Backend Integration

**Supabase Integration**: When backend services are required, we choose Supabase for its rapid deployment capabilities—providing both client SDKs and PostgreSQL database setup with minimal configuration.

**Real-time Features**: For streaming applications, Supabase's real-time subscriptions handle live data synchronization between viewers and streamers seamlessly.

## Why This Workflow Works

**Speed**: Traditional development cycles of months are compressed into weeks.

**Quality**: AI-generated code provides solid foundations that human refinement elevates to production quality.

**Cost-Effectiveness**: Reduced development time translates directly to lower costs and faster market entry.

**Scalability**: The workflow adapts to projects of any complexity, from simple utilities to feature-rich applications.

## Key Takeaways

1. **AI as Foundation Builder**: Claude Code excels at creating comprehensive project structures and implementing core functionality based on natural language descriptions.

2. **Human Refinement is Essential**: While AI provides excellent foundations, human expertise in Cursor ensures production-ready code quality.

3. **Asset Generation Strategy**: Success with AI-generated assets requires thoughtful prompt engineering and competitive analysis.

4. **Global-First Approach**: Planning for international markets from day one, rather than retrofitting localization, saves significant time and resources.

This workflow has transformed how we approach mobile development, enabling rapid iteration and faster time-to-market while maintaining high code quality standards. The combination of Claude Code's intelligent generation and human refinement creates a powerful development pipeline that scales with project complexity.

*Ready to streamline your development process? Start with a clear project description and let AI handle the foundation while you focus on the unique value your application brings to users.*

Discover my journey building a Catalan verb conjugation mobile app using React Native, Python, and web scraping. Learn about the tech stack and development process behind this educational language learning tool.

EdTech Innovation: Developing Cross-Platform Language Learning Solutions

---
title: "EdTech Innovation: Developing Cross-Platform Language Learning Solutions"
date: "2024-12-28"
description: "Discover my journey building a Catalan verb conjugation mobile app using React Native, Python, and web scraping. Learn about the tech stack and development process behind this educational language learning tool."
slug: "catalan-verbs-mobile-app-5abm"
tags: "#mobileapp #reactnative #indiedev"
---

# Catalan Verbs: My Birthday Gift to Language Learners

I'm thrilled to announce that I've just released a new mobile application to celebrate my birthday! As someone living near Barcelona, I've found myself increasingly drawn to the beautiful Catalan language. This fascination inspired me to create a tool that could help others on their language learning journey.

## Why Catalan?

Catalan is not only the official language of Catalonia but also a rich linguistic treasure with a fascinating history. Living close to Barcelona has given me the opportunity to immerse myself in this melodic language, and I wanted to share my passion with fellow language enthusiasts worldwide.

## The Development Journey

Creating this app was both a learning experience and a labor of love. I tackled one of the most challenging aspects of Catalan - verb conjugations - and turned it into an accessible mobile tool for learners of all levels.

### Tech Stack

- **React Native**: For cross-platform mobile development
- **Scrapy**: To gather comprehensive verb conjugation data
- **Python**: For automating translations and data processing
- **Cursor**: An AI-powered code editor that significantly accelerated my development workflow

The combination of these technologies allowed me to create a responsive, user-friendly application with accurate linguistic content.

## Features

The app provides:
- Comprehensive conjugation tables for Catalan verbs
- Search functionality to quickly find specific verbs
- Offline access to all content
- Clean, intuitive interface designed for learners
- Example sentences to understand usage in context

## Ready to Master Catalan Verbs?

Whether you're a beginner just starting your Catalan journey or an advanced learner polishing your skills, this app offers the perfect companion for mastering verb conjugations.

Download now:
- 📱 **iOS**: [App Store](https://apps.apple.com/es/app/catalan-verbs/id6738144158)
- 🤖 **Android**: [Google Play](https://play.google.com/store/apps/details?id=co.bitscorp.cat)

I welcome your feedback and suggestions for future updates!

#CatalanLanguage #LanguageLearning #Education #ReactNative #TechInEducation


Discover how to learn Spanish with a Chrome extension. Learn about the development process and the benefits of using a Chrome extension for learning Spanish.

Browser Extension Monetization: Building Educational Tools with Payment Integration

---
title: "Browser Extension Monetization: Building Educational Tools with Payment Integration"
date: "2024-09-08"
description: "Discover how to learn Spanish with a Chrome extension. Learn about the development process and the benefits of using a Chrome extension for learning Spanish."
slug: "learn-spanish-chrome-extension-b12"
tags: "#chrome #extension"
---

# Introducing My New Spanish Learning Chrome Extension

I'm excited to announce that I've just published a new Chrome extension designed to help you learn Spanish! I developed it quickly, but it has already become an invaluable tool in my own Spanish learning journey over the past few months.

## [Learn Spanish Chrome Extension](https://chromewebstore.google.com/detail/learn-spanish/onnolcnjhjbmcgfppkmamfkadklopbkj?ref=producthunt)

### Key Features:
- **Free Plan**: Learn 10 new Spanish words daily
- **Premium Option**: I've integrated Whop payment processing to offer a one-time lifetime payment that unlocks unlimited words with each new tab

While monetization wasn't my primary goal, I wanted to experiment with implementing a payment system in a Chrome extension as a learning experience.

If you're looking for a simple, effective way to gradually build your Spanish vocabulary, give it a try!

Thank you for reading!




Discover how to integrate OpenAI into your React Native application. Learn about the development process and the benefits of using OpenAI for your application.

Accelerating Mobile Innovation: Integrating OpenAI Intelligence into React Native Applications

---
title: "Accelerating Mobile Innovation: Integrating OpenAI Intelligence into React Native Applications"
date: "2024-06-10"
description: "Discover how to integrate OpenAI into your React Native application. Learn about the development process and the benefits of using OpenAI for your application."
slug: "react-native-and-openai-4e9a"
tags: "#reactnative #openai #mobileapp"
---

# Integrating OpenAI with React Native: A Fun Experiment

I recently developed a simple application using OpenAI/ChatGPT and was amazed by how enjoyable and straightforward the process was.

[Watch the app preview here](https://www.youtube.com/watch?v=4NjaXtJHTwM)

While the app is admittedly more of a novelty than a serious tool, I was particularly impressed by the ability to upload images and ask specific questions about them. This was my first experience with AI integration, and though it might seem obvious to developers already working with AI models, I found it fascinating.

Let's examine the core communication function to better understand how the app works:

```typescript
const sendMessage = async (image_url: string, language: AppLanguage) => {
  try {
    const openai = new OpenAI({
      apiKey: OPENAI_API_KEY, // This is the default and can be omitted
    });

    const { data: completion } = await openai.chat.completions
      .create({
        model: "gpt-4-turbo",
        stream: false,
        messages: [
          {
            role: "system",
            content: `
You are palm reader, explain by reading palm the user background, life, future, fate. Please write at least 10 setences about each topic:
- user line of life
- user line of heart
- user line of mind
- user line of fate
- user extra information that we need to mention

Only provide a RFC8259 compliant JSON response:
[
  {
    "line_life": "user line of life",
    "line_heart": "user line of heart",
    "line_mind": "user line of mind",
    "line_fate": "user line of fate",
    "line_extra": "user extra information"
  }
]`,
          },
          {
            role: "user",
            content: [
              {
                type: "text",
                text: `
- user line of life, 10+ sentences
- user line of heart, 10+ sentences
- user line of mind, 10+ sentences
- user line of fate, 10+ sentences
- user extra information that we need to mention, 10+ sentences
                `,
              },
              {
                type: "text",
                text: `Use language ${language} for answers.`,
              },
              {
                type: "text",
                text: 'Describe my palm but in format { "line_heart": "text...", "line_life": "text...", "line_mind": "text...", "line_fate": "text...", "line_extra": "text..." }',
              },
              {
                type: "image_url",
                image_url: {
                  url: `data:image/jpeg;base64,${image_url}`,
                },
              },
            ],
          },
        ],
      })
      .withResponse();

    const replies = completion.choices
      .flatMap((choice) => {
        try {
          if (choice.message.content === null || choice.message.content === undefined) {
            return [];
          } else {
            const messages = JSON.parse(choice.message.content);

            return messages;
          }
        } catch (error) {
          Sentry.Native.captureException(error);

          return [];
        }
      })
      .reduce((acc, cur) => ({ ...acc, ...cur }), {});

    return replies;
  } catch (error) {
    Sentry.Native.captureException(error);
  }
};
```

As you can see, I used specific prompts to format the responses in JSON and passed an image for analysis. I also localized the app by supporting English, Spanish, German, French, and Russian languages. Simply instructing ChatGPT to respond in a specific language worked perfectly out of the box—it's like mathematical magic!

I plan to publish the app, but there's a significant challenge: using `gpt-4-turbo` is quite expensive. The app will likely remain available for a while, but I may need to disable it eventually due to the costs involved.






Discover how we developed the mobile app using ReactNative / Supabase / ChatGPT and then published it to the App Store and Google Play.

Rapid Mobile Development: Two-Week App Store Success Story

---
title: "Rapid Mobile Development: Two-Week App Store Success Story"
date: "2023-10-01"
description: "Discover how we developed the mobile app using ReactNative / Supabase / ChatGPT and then published it to the App Store and Google Play."
slug: would-it-be-interesting-for-anyone-to-have-the-text-based-guide-on-how-we-develop-pushupbitscorpco-mobile-app-for-2-weeks-2bae
tags: #mobileapp #reactnative #supabase #chatgpt
---

I'm considering creating a text-based course that walks through how we developed our mobile app using React Native, Supabase, and ChatGPT, then successfully published it to both the App Store and Google Play.

In just one month, our app gained over 60 users through organic traffic alone (no paid advertising). It currently tracks between 20-40 daily sports activities from active users.

From my experience, fitness apps tend to receive more organic traffic on iOS compared to Android platforms.

Check out our app:
- [App Store](https://apps.apple.com/us/app/pushup-challenges/id6450053262)
- [Google Play](https://play.google.com/store/apps/details?id=co.bitscorp.pushup)
- [Web](https://pushup.bitscorp.co)



Discover how to build a mobile app to improve your daily habits. Learn about the development process and the benefits of using a mobile app for your daily habits.

Health Tech Development: Creating Habit-Building Fitness Applications

---
title: "Health Tech Development: Creating Habit-Building Fitness Applications"
date: "2023-09-11"
description: "Discover how to build a mobile app to improve your daily habits. Learn about the development process and the benefits of using a mobile app for your daily habits."
slug: "push-up-mobile-app-4lll"
tags: "#mobileapp #appstore #googleplay"
---

# Introducing Push Up: A Fitness Habit Builder

We're excited to share our pet project designed to improve health through daily habits!

## What is Push Up?

Push Up is a simple fitness app focused on two fundamental exercises: push-ups and squats. The concept is straightforward - invite friends and start building healthy exercise habits together.

This app evolved from a humble Google spreadsheet tracking system into a full-featured mobile application that makes fitness social and fun.

## Why We Created It

Many of us spend long hours at our desks, which can negatively impact our health. Push Up encourages short, effective exercise breaks throughout your workday to keep you energized and healthy.

## Try It Today!

Ready to transform your daily routine? Visit [Push Up](https://pushup.bitscorp.co/) and start your fitness journey today.

We hope this app helps you improve your lifestyle during your busy workday!





Learn how to optimize Elixir Phoenix actions with large JSON responses by implementing cached, gzipped values.

Optimizing Elixir Phoenix Actions with Huge JSON Responses Using Cached, Gzipped Values

---
title: "Optimizing Elixir Phoenix Actions with Huge JSON Responses Using Cached, Gzipped Values"
date: "2023-07-19"
description: "Learn how to optimize Elixir Phoenix actions with large JSON responses by implementing cached, gzipped values."
slug: "optimizing-elixir-phoenix-action-with-huge-json-response-by-responding-by-cached-gzipped-values-1d64"
tags: "#elixir #phoenix #phoenixframework"
---

Hello everyone,

I'm excited to be back and share some recent optimizations I've implemented for a client project. We've been developing a React Native mobile application that includes a wiki-like section providing users with step-by-step health improvement information.

## The Challenge

One significant challenge we faced was handling a massive JSON response—approximately 20MB in size—retrieved from a single endpoint during the app's loading process. While splitting API requests and loading content on-demand was an option, we also wanted to ensure offline accessibility for users. This made a one-time load during the initial launch beneficial, despite taking around 6 seconds depending on internet speed.

## The Solution

Looking for a quick optimization, particularly for the wiki endpoints, we found the perfect solution in the [cachex](https://github.com/whitfin/cachex) library. This impressive tool includes a `warmer` module that automatically refreshes cached data either on boot or after a specified `ttl` (time-to-live).

By integrating cachex into our system, we've significantly improved the loading process, providing users with a smoother experience while maintaining offline accessibility. Let me walk you through how we implemented this caching solution for our Phoenix Controller actions with large JSON responses.

```elixir
defmodule BlogApp.Cache.PostsWarmer do
  use Cachex.Warmer

  alias BlogApp.Posts

  require Logger
  require Jsonrs

  @cache_table :blog_app_cache
  @posts_cache_key {:posts, :list_posts}

  def interval, do: :timer.minutes(60)

  def execute(_args) do
    data = [
      get_posts()
    ]

    {:ok, data, [ttl: :timer.minutes(60)]}
  end

  def get_cached_posts() do
    get_or_put(@posts_cache_key)
  end

  defp get_posts() do
    posts = Posts.list_published_posts()

    posts =
      BlogAppWeb.Api.V1.PostsView.render("index.json", %{
        posts: posts
      })
      |> Jsonrs.encode!()
      |> :zlib.gzip()

    {@posts_cache_key, posts}
  end

  defp get_or_put(key) do
    case Cachex.get(@cache_table, key) do
      nil ->
        case key do
          @posts_cache_key ->
            {key, posts} = get_posts()

            Cachex.put(@cache_table, key, posts)
            Cachex.get(@cache_table, key)

          _ ->
            Logger.error("[your_app] cache key not found: #{inspect(key)}")

            nil
        end

      value ->
        value
    end
  end
end
```

## Implementation Steps

First, create a `cache.ex` file in the lib folder:

```elixir
defmodule BlogApp.Cache do
  @moduledoc """
  Cache
  """
  @cache_table :blog_app_cache

  import Cachex.Spec

  def child_spec(_init_arg) do
    %{
      id: @cache_table,
      type: :supervisor,
      start:
        {Cachex, :start_link,
         [
           @cache_table,
           [
             warmers: [
               warmer(module: BlogApp.Cache.PostsWarmer, state: "")
             ]
           ]
         ]}
    }
  end
end
```

Next, add the warmer module to your `application.ex`:

```elixir
defmodule BlogApp.Application do
  @moduledoc false

  use Application

  def start(_type, _args) do
    children = [
      # ... existing code ...
      {BlogApp.Cache, []}
    ]

    Supervisor.start_link(children, strategy: :one_for_one, name: BlogApp.Supervisor)
  end
end
```

Finally, integrate the cached, gzipped data in your Phoenix controller:

```elixir
def index(conn, _params) do
  {:ok, posts} = PostsWarmer.get_cached_posts()

  conn
  |> put_resp_header("Content-Encoding", "gzip")
  |> put_resp_content_type("application/json")
  |> send_resp(200, posts)
end
```

## Results

This simple implementation provides a powerful speed boost. For processing large JSON files, we've also started using [jsonrs](https://github.com/benhaney/Jsonrs), which further enhances performance.

The key benefits of this approach include:
- Significantly reduced response times
- Decreased server load
- Improved user experience
- Maintained offline functionality

Thank you for reading!

---

Available for consulting in Elixir, Go, JS, and Big Data.
Visit our website: [bitscorp.co](https://bitscorp.co)
Find me on GitHub: [github.com/oivoodoo](https://github.com/oivoodoo), [github.com/bitscorp](https://github.com/bitscorp)
My other blog: [https://dev.to/oivoodoo](https://dev.to/oivoodoo)

```elixir
defmodule BlogApp.Cache.PostsWarmer do
  use Cachex.Warmer

  alias BlogApp.Posts

  require Logger
  require Jsonrs

  @cache_table :blog_app_cache
  @posts_cache_key {:posts, :list_posts}

  def interval, do: :timer.minutes(60)

  def execute(_args) do
    data = [
      get_posts()
    ]

    {:ok, data, [ttl: :timer.minutes(60)]}
  end

  def get_cached_posts() do
    get_or_put(@posts_cache_key)
  end

  defp get_posts() do
    posts = Posts.list_published_posts()

    posts =
      BlogAppWeb.Api.V1.PostsView.render("index.json", %{
        posts: posts
      })
      |> Jsonrs.encode!()
      |> :zlib.gzip()

    {@posts_cache_key, posts}
  end

  defp get_or_put(key) do
    case Cachex.get(@cache_table, key) do
      nil ->
        case key do
          @posts_cache_key ->
            {key, posts} = get_posts()

            Cachex.put(@cache_table, key, posts)
            Cachex.get(@cache_table, key)

          _ ->
            Logger.error("[your_app] cache key not found: #{inspect(key)}")

            nil
        end

      value ->
        value
    end
  end
end

```elixir
defmodule BlogApp.Cache do
  @moduledoc """
  Cache
  """
  @cache_table :blog_app_cache

  import Cachex.Spec

  def child_spec(_init_arg) do
    %{
      id: @cache_table,
      type: :supervisor,
      start:
        {Cachex, :start_link,
         [
           @cache_table,
           [
             warmers: [
               warmer(module: BlogApp.Cache.PostsWarmer, state: "")
             ]
           ]
         ]}
    }
  end
end

```elixir
defmodule BlogApp.Application do
  @moduledoc false

  use Application

  def start(_type, _args) do
    children = [
      # ... existing code ...
      {BlogApp.Cache, []}
    ]

    Supervisor.start_link(children, strategy: :one_for_one, name: BlogApp.Supervisor)
  end
end

```elixir
def index(conn, _params) do
  {:ok, posts} = PostsWarmer.get_cached_posts()

  conn
  |> put_resp_header("Content-Encoding", "gzip")
  |> put_resp_content_type("application/json")
  |> send_resp(200, posts)
end


Discover how to sell your game arts and complete games with discounts via Gumroad. Learn about the development process and the benefits of using Gumroad for your ecommerce needs.

Digital Asset Monetization: Building Revenue Streams Through Game Asset Sales

---
title: "Digital Asset Monetization: Building Revenue Streams Through Game Asset Sales"
date: "2021-12-27"
description: "Discover how to sell your game arts and complete games with discounts via Gumroad. Learn about the development process and the benefits of using Gumroad for your ecommerce needs."
slug: "road-to-ecommerce-via-gumroad--20nh"
tags: "#gameart #gamedev #ecommerce #gumroad"
---

# Selling Game Assets and Complete Games on Gumroad

Hi everyone!

I've recently started selling my game art assets and complete Unity-based games on Gumroad. These resources could be valuable for other developers looking for ready-made assets or inspiration.

My current focus is on developing new games, with a tower defense style game coming next month to test audience interest. However, I need to raise some budget for marketing my upcoming game, and Gumroad seems like the perfect platform for this. I've been impressed by how easy it is to create product pages and start selling right away.

## Available Products

### Complete Games
- [Complete Game - Don't Fall](https://balconygames.gumroad.com/l/game-dont-fall/happycoding?_gl=1*2dery6*_ga*MTg3ODY3OTMxNS4xNjM3MTgzMjQw*_ga_6LJN6D94N6*MTY0MDY0Mjc2MC4xMy4xLjE2NDA2NDI5MjUuMA..)
  - Available on: [Google Play](https://play.google.com/store/apps/details?id=com.balconygames.dontfall) and [App Store](https://apps.apple.com/es/app/dont-fall-by-balcony-games/id1460842492)

### Game Art Assets
- [Game Art - Don't Fall (older version)](https://balconygames.gumroad.com/l/dont-fall-art/bsfr4ww?_gl=1*1k5lihx*_ga*MTg3ODY3OTMxNS4xNjM3MTgzMjQw*_ga_6LJN6D94N6*MTY0MDY0Mjc2MC4xMy4xLjE2NDA2NDI5OTQuMA..)

- [Game Art - Snake](https://balconygames.gumroad.com/l/snake-game-art/bsfr4ww?_gl=1*1jr3fd8*_ga*MTg3ODY3OTMxNS4xNjM3MTgzMjQw*_ga_6LJN6D94N6*MTY0MDY0Mjc2MC4xMy4xLjE2NDA2NDMwMTIuMA..)
  - See it in action: [Google Play](https://play.google.com/store/apps/details?id=com.balconygames.snake)

- [Game Art - Paint Swipe](https://balconygames.gumroad.com/l/paiint-swipe-game/bsfr4ww?_gl=1*o9b1hp*_ga*MTg3ODY3OTMxNS4xNjM3MTgzMjQw*_ga_6LJN6D94N6*MTY0MDY0Mjc2MC4xMy4xLjE2NDA2NDMwMzIuMA..) - This game is currently unfinished, but I plan to polish it and share the source code in the future.

I hope you find these resources useful for your projects!

Thank you,

Alex


Discover how to create a Phoenix umbrella proxy application. Learn about the development process and the benefits of using a proxy application for your Phoenix projects.

Phoenix umbrella proxy application.

---
title: "Phoenix umbrella proxy application."
date: "2021-06-15"
description: "Discover how to create a Phoenix umbrella proxy application. Learn about the development process and the benefits of using a proxy application for your Phoenix projects."
slug: "phoenix-umbrella-proxy-application-7kc"
tags: "#elixir #phoenixframework #phoenix #development"
---

Hey everyone!

It's been quite a while since I last wrote here. I've been busy developing games with my free-time company [balconygames](https://balcony.games). We've made good progress, though the market remains challenging due to the high costs of user acquisition.

Today, I'd like to share an example of a proxy application for a Phoenix umbrella project. This might be useful for those facing similar issues with code reloading and WebSocket support. The example has four apps inside the `apps/` directory: `proxy`, `web` (Phoenix), `admin` (Phoenix), and `db` (shared Ecto project).

Without further ado, here's the implementation:

```elixir
defmodule YourApp.Proxy.Application do
  @moduledoc false
  use Application

  alias Phoenix.LiveReloader.Socket, as: LiveReloadSocket

  require Logger

  def start(_type, _args) do
    import Supervisor.Spec, warn: false

    require_code_reloading?(:your_app_web, YourAppWeb.Endpoint)

    opts = [strategy: :one_for_one, name: YourApp.Proxy.Supervisor]
    Supervisor.start_link(children(Mix.env()), opts)
  end

  def children(:test), do: []

  def children(_) do
    proxy_children = [
      {
        Plug.Cowboy,
        scheme: :http,
        plug: YourApp.Proxy.Builder,
        port: port(),
        dispatch: [
          {:_,
           [
             # your_app_web
             web_phoenix_live_reload(),
             web_phoenix_live_view(),
             web_websocket(),
             # your_app_admin
             admin_phoenix_live_reload(),
             admin_phoenix_live_view(),
             admin_websocket(),
             # proxy
             master_proxy()
           ]}
        ]
      }
    ]

    # - proxy endpoints
    #    - /api endpoints
    #    - /dev/admin pages
    # - web watchers for webpacker and code reloading
    # - admin watchers for webpacker and code reloading
    children =
      proxy_children ++
        watcher_children(
          :your_app_web,
          YourAppWeb.Endpoint
        ) ++
        watcher_children(
          :your_app_admin_web,
          YourAppAdminWeb.Endpoint
        )

    children
  end

  defp watcher_children(otp_app, mod) do
    conf = Application.get_env(otp_app, mod)

    unless Mix.env() == :test do
      Enum.map(conf[:watchers], fn {cmd, args} ->
        {Phoenix.Endpoint.Watcher, watcher_args(cmd, args)}
      end)
    else
      []
    end
  end

  defp watcher_args(cmd, cmd_args) do
    {args, opts} = Enum.split_while(cmd_args, &is_binary(&1))
    {cmd, args, opts}
  end

  def port do
    (System.get_env("PORT") || "4000") |> String.to_integer()
  end

  def web_phoenix_live_reload do
    websocket_handler(
      "/phoenix/live_reload/socket/websocket",
      YourAppWeb.Endpoint,
      {LiveReloadSocket, :websocket}
    )
  end

  def web_phoenix_live_view do
    websocket_handler(
      "/live",
      YourAppWeb.Endpoint,
      {Phoenix.LiveView.Socket, :websocket}
    )
  end

  def web_websocket do
    websocket_handler(
      "/cable/websocket",
      YourAppWeb.Endpoint,
      {YourAppWeb.UserSocket, websocket: true}
    )
  end

  def admin_phoenix_live_reload do
    websocket_handler(
      "/dev/admin/phoenix/live_reload/socket/websocket",
      YourAppAdminWeb.Endpoint,
      {LiveReloadSocket, :websocket}
    )
  end

  def admin_phoenix_live_view do
    websocket_handler(
      "/dev/admin/live",
      YourAppAdminWeb.Endpoint,
      {Phoenix.LiveView.Socket, :websocket}
    )
  end

  def admin_websocket do
    websocket_handler(
      "/dev/admin/websocket",
      YourAppAdminWeb.Endpoint,
      {YourAppAdminWeb.UserSocket, websocket: true}
    )
  end

  def master_proxy do
    {:_, Plug.Cowboy.Handler, {YourApp.Proxy.Plug, []}}
  end

  defp websocket_handler(path, endpoint, options) do
    {path, Phoenix.Endpoint.Cowboy2Handler, {endpoint, options}}
  end

  defp require_code_reloading?(otp_app, mod) do
    conf = Application.get_env(otp_app, mod)

    if conf[:code_reloader] do
      Phoenix.CodeReloader.Server.check_symlinks()
    end
  end
end
```

That's it! This proxy application handles routing for both your web and admin Phoenix applications, while properly supporting WebSockets, LiveView, and code reloading.


Discover the latest updates and features of Crystal Blast 2.0, the latest version of our popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types.

Driving User Engagement: Crystal Blast 2.0 - A Case Study in Mobile Game Iteration

---
title: "Driving User Engagement: Crystal Blast 2.0 - A Case Study in Mobile Game Iteration"
date: "2020-07-20"
description: "Discover the latest updates and features of Crystal Blast 2.0, the latest version of our popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types."
slug: "new-version-of-crystal-blast-3922"
tags: "#gamedev, #indiegame, #indiegamedev"
---

# New Version of Crystal Blast 2.0 Released!

Hello everyone!

We're excited to announce that we've just published the new version of [Crystal Blast on Google Play](https://play.google.com/store/apps/details?id=com.balconygames.CrystalBlast) and are currently awaiting review approval for the [App Store version](https://apps.apple.com/us/app/crystal-blast/id1451868968).

## What's New

This update includes several exciting improvements:

- Wonderful new sound effects
- Additional ways to earn coins (allowing players to upgrade their weapons and ships faster)
- Competitive leaderboard system

## Technical Improvements

As part of this build, I've implemented my own game server for:
- Collecting analytics
- Storing player game settings
- Managing the leaderboard

I'm currently working on cleaning up the server-side code and plan to share it with the community as a resource for indie game developers.

## Tech Stack
- Go
- Redis
- ClickHouse
- NSQ
- Ansible + Docker Compose for streamlined deployment

Thank you for your continued support!

Best regards,
Alexandr



Discover how to build a game server for indie developers. Learn about the development process and the benefits of using a game server for your indie games.

Democratizing Game Development: Building Scalable Infrastructure for Independent Studios

---
title: "Democratizing Game Development: Building Scalable Infrastructure for Independent Studios"
date: "2020-06-17"
description: "Discover how to build a game server for indie developers. Learn about the development process and the benefits of using a game server for your indie games."
slug: "started-to-build-game-server-for-indie-developers-1j9m"
tags: "#go #status #gamedev"
---

I haven't written anything for the past few months due to home isolation and being swamped with work. Searching for new freelance contracts to fill my free time became quite exhausting, so I decided to challenge myself with something new.

I've recently started developing a generic-purpose game server for indie developers. So far, I've implemented key-value storage, leaderboards, and guest authentication via device ID. Currently, I'm working on adding social networking features.

I'm aware that Nakama exists as a solution, but creating my own server is both a personal challenge and a practical application for my current games in the market. Starting with version 2.1, Crystal Blast will use my own analytics platform and storage instead of Firebase.

My goal is to move away from external tools like Firebase and game services, bringing everything in-house while keeping costs as low as possible.

I plan to open-source this project in 2-3 months, once I've confirmed it works reliably with games in production.

Update: [Crystal Blast](https://crystalblast.page.link/install) will soon feature sounds, leaderboards, and settings synchronization across platforms using social sign-in.





From Concept to Market Success: The Crystal Blast Development Journey

---
title: "From Concept to Market Success: The Crystal Blast Development Journey"
date: "2020-04-12"
description: "Discover the latest updates and features of Crystal Blast 2.0, the latest version of our popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types."
slug: "crystal-blast-2-0-303l"
tags: "#gamedev #indiedev #indiegamedev #unity"
---

# Crystal Blast 2.0 - New Release!

We're excited to announce that we've finally published our latest update: [Crystal Blast 2.0](https://crystalblast.page.link/install)!

## What's New:
- 37 new backgrounds
- Completely redesigned gameplay UI
- Improved gameplay balance
- New crystal types

This has been a challenging journey for our team this year. We've dedicated countless nights to development, working on the game during whatever free time we could find.

Today, we received our first purchase since the update, which has given us renewed energy to continue polishing the game:

![First purchase celebration](https://dev-to-uploads.s3.amazonaws.com/i/apgg9a7qi1aihzlrjgxs.png)

Recently, our balcony game development sessions have expanded to include friends who are also working from their balconies due to quarantine restrictions. We hope this situation resolves soon so everyone can fully enjoy the upcoming summer.

[![Crystal Blast 2.0 - Download Now](https://dev-to-uploads.s3.amazonaws.com/i/og7bhvbep8qcasg6u4f2.png)](https://crystalblast.page.link/install)



Discover how to mirror traffic in NGINX using the mirror module. Learn about the development process and the benefits of using the mirror module for your NGINX configuration.

Production-Grade Traffic Analysis: Advanced Load Balancing with NGINX Mirror Module

---
title: "Production-Grade Traffic Analysis: Advanced Load Balancing with NGINX Mirror Module"
date: "2019-12-20"
description: "Discover how to mirror traffic in NGINX using the mirror module. Learn about the development process and the benefits of using the mirror module for your NGINX configuration."
slug: "traffic-mirroring-by-nginx-mirror-module-2i8j"
tags: "#nginx #mirroring #api"
---

# Traffic Mirroring with NGINX Mirror Module

A few months ago, I decided to migrate one of our company services from PHP to Go. This decision came about because we lacked engineers to continue developing or supporting our existing PHP endpoints, while new endpoints were being developed in Go. Although I have substantial experience with Ruby, Go, and JavaScript, I wasn't eager to invest time in enhancing legacy endpoints written years ago.

## The Migration Challenge

When dealing with high-traffic services, choosing the right migration strategy is crucial. While researching options, I discovered the NGINX mirror module in the official documentation: [https://nginx.org/en/docs/http/ngx_http_mirror_module.html](https://nginx.org/en/docs/http/ngx_http_mirror_module.html).

This module seemed like an ideal solution for my use case. To create a prototype, I used Docker Compose to organize all services in one place and implemented logging for basic requests.

## Implementation Example

Here's a simplified version of my setup:

```conf
version: "3"

services:
  entry:
    image: nginx
    volumes:
     - ./v2/nginx.template:/etc/nginx/conf.d/default.conf
    links:
      - v1
      - v2_backend
    ports:
     - "80:80"
    environment:
     - NGINX_PORT=80
    command: /bin/bash -c "exec nginx -g 'daemon off;'"

  v1:
    image: nginx
    volumes:
     - ./v1/nginx.template:/etc/nginx/conf.d/default.conf
    links:
      - v1_backend
    expose:
     - "80"
    environment:
     - NGINX_PORT=80
    command: /bin/bash -c "exec nginx -g 'daemon off;'"

  v1_backend:
    image: example-image1:latest
    expose:
      - "9000"

  v2_backend:
    image: example-image2:latest
    expose:
      - "5000"
```

### PHP Configuration (v1/nginx.template)

This is the NGINX configuration file for the PHP service using FastCGI:

```conf
upstream backend {
  server v1_backend:9000;
}

server {
    listen       80;
    server_name  _;
    root /var/www/html;

    location / {
        try_files $uri $uri/ @rewrite;
    }

    location @rewrite {
      rewrite ^/(.*)$ /index.php?q=$1 last;
    }

    error_page  404              /404.html;
    error_page   500 502 503 504  /50x.html;

    location ~ .php$ {
        try_files  $uri =404;

        fastcgi_pass   backend;
        fastcgi_index  index.php;
        fastcgi_param  SCRIPT_FILENAME /var/www/html$fastcgi_script_name;
        include        fastcgi_params;

        fastcgi_max_temp_file_size 0;

        fastcgi_buffers 32 256k;
    }
}
```

### Go Configuration with Mirroring (v2/nginx.template)

This NGINX template serves our new Go API while mirroring traffic to it:

```conf
upstream v1.backend {
    server v1;
}

upstream v2.backend {
    server v2_backend:5000;
}

server {
    listen 80;
    server_name _;

    location / {
      mirror /mirror;
      mirror_request_body on;

      proxy_pass http://v1.backend;
    }

    location = /mirror {
      internal;

      proxy_pass http://v2.backend$request_uri;
      proxy_set_header X-SERVER-PORT $server_port;
      proxy_set_header X-SERVER-ADDR $server_addr;
      proxy_set_header X-Original-URI $request_uri;
      proxy_set_header HOST $http_host;
      proxy_set_header X-REAL-IP $remote_addr;
    }
}
```

## How It Works

This example demonstrates a basic approach to achieve a smooth migration. The PHP application serves as the primary application, while the Go app functions as the V2 API.

The key configuration is `mirror /mirror;`, which instructs NGINX to process each request through the `/mirror` location and then forward it to the v2 backend. This allows us to verify traffic behavior through console logs.

Once the V2 application is functioning correctly, we can completely remove V1 and update the NGINX template to a new version without the mirroring configuration.

## Conclusion

Using NGINX's mirror module provides an elegant solution for gradually migrating between services while ensuring continuity. This approach allows you to validate your new implementation under real traffic conditions before fully committing to the switch.

Thanks for reading!


Discover the latest updates and features of Crystal Blast, the popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types.

Product Evolution in Action: Strategic Feature Development for Crystal Blast Mobile Game

---
title: "Product Evolution in Action: Strategic Feature Development for Crystal Blast Mobile Game"
date: "2019-08-07"
description: "Discover the latest updates and features of Crystal Blast, the popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types."
slug: "game-crystal-blast-the-recent-update-26l3"
tags: "#gamedev #unity #gameart"
---

Hi everyone!

Although we haven't had much time to work lately, we're still dedicating our free time to game development. We hope it becomes profitable in the future! :)

We're excited to announce that we've recently published Crystal Blast on both the App Store and Google Play with several updates.

## Known Challenges We're Facing:

- **Marketing is challenging** - It's incredibly difficult to promote games without purchasing ads. Google and Apple require significant investment to boost games to the top of search results or trending lists. We contacted two publishers, but it seems the gameplay of our [Crystal Blast](https://play.google.com/store/apps/details?id=com.balconygames.CrystalBlast) isn't as attractive as current Hyper Casual trends. For now, we've tried boosting in specific countries with low cost-per-install and optimized our descriptions to try reaching the top 5 in Google Play searches. Google Play Store works well, but targeting specific audience attributes is much harder compared to Facebook ads.

- **Cross-platform development** - While Unity greatly helps with game development, "cross-platform" doesn't mean it's simple to support Game Center, Google Play Services, push notifications, and other platform-specific features.

- **Analytics platforms** - Google [Firebase](https://firebase.google.com/) is excellent, offering out-of-the-box BigQuery integration on their Pay-as-You-Go plan. It makes it easy to save queries for traffic analysis, and Data Studio is great for building charts based on BigQuery data sources.

- **Distribution tools** - Microsoft [appcenter.ms](appcenter.ms) is fantastic for distributing to testers via Fastlane from a local machine. However, it currently can't distribute Android Bundles, which became a major requirement in Google Play as of August 1st. [Azure](http://azure.microsoft.com) Application Insights is also great, though reviewing events is more challenging compared to Firebase and Data Studio. We're still evaluating both platforms.

- **Push notification systems** - [appcenter.ms](appcenter.ms) lacks robust support for push notification campaigns, whereas [Firebase](https://firebase.google.com/) offers predictions on user churn and makes it much easier to set up notifications for targeted audiences.

- **Game services integration** - [CloudOnce](http://jizc.github.io/CloudOnce/) is a wonderful Unity plugin that supports Play Game Services and Game Center. It's also easy to write your own provider if you want to expand to Amazon or Chinese markets.

We would greatly appreciate any feedback about the game!

P.S.: We're looking for a game art designer to join our team (no profit for now, but lots of fun and potential opportunities to grow together).

More updates coming soon! :)

[Google Play](https://play.google.com/store/apps/details?id=com.balconygames.CrystalBlast)
[App Store](https://apps.apple.com/us/app/crystal-blast/id1451868968)


Discover why we should sleep. Learn about the development process and the benefits of sleeping.

Work-Life Balance in Tech: Managing Multiple Projects and Continuous Learning

---
title: "Work-Life Balance in Tech: Managing Multiple Projects and Continuous Learning"
date: "2019-03-19"
description: "Discover why we should sleep. Learn about the development process and the benefits of sleeping."
slug: "why-should-we-sleep--50a0"
tags: "#dev"
---

These days I'm working full-time for a great game company from Canada, but at the same time, I would love to do more development work in my free time while still spending quality time with my family. I believe that over the last 10 years, I've become quite addicted to this lifestyle. Everything is progressing so rapidly in web development, game design, and machine learning - it's becoming increasingly easy to learn how to build AI, create designs in Adobe Illustrator, or build robots. Platforms like Coursera, Udemy, and Udacity are making our lives easier, but simultaneously making it harder to choose the right courses due to our limited time.

Why should we sleep when there are so many opportunities around us? :)

Perhaps it's time to invent something for our brains and health that would give us more time for side projects!

Feeling good anyway.


Game in the same style as a classic snake

Reimagining Classic Gaming: Modern Snake Game Development with Advanced Mechanics

---
title: "Reimagining Classic Gaming: Modern Snake Game Development with Advanced Mechanics"
date: "2019-03-15"
description: "Game in the same style as a classic snake"
slug: "gamedev-snake-1f5f"
tags: "#gamedev #unity #gameart"
---

Hi everyone!

I'm excited to announce that I've just released a new game! However, for upcoming releases, I'll be focusing on adding nice features to my previous games rather than creating new ones. I've started learning Adobe Animation, which reminds me of Flash that I used years ago.

Continuing this development journey has become more challenging, but I'm planning to dedicate more of my free time to animation or possibly find someone to collaborate with on this aspect.

[https://play.google.com/store/apps/details?id=com.balconygames.snake](https://play.google.com/store/apps/details?id=com.balconygames.snake)

I hope you'll find this game to be a great time-killer! :)

Thank you for reading!

![screenshot1](https://thepracticaldev.s3.amazonaws.com/i/14fyjjrhqz2lmz7olh7y.png)
![screenshot2](https://thepracticaldev.s3.amazonaws.com/i/4ayjli3rat53x9hi035t.png)



Hyper-Casual Gaming Strategy: Creating Addictive Gameplay Experiences

---
title: "Hyper-Casual Gaming Strategy: Creating Addictive Gameplay Experiences"
date: "2019-02-27"
description: Discover the latest updates and features of Crystal Blast 2.0, the latest version of our popular game. Learn about the new backgrounds, gameplay UI, balance improvements, and crystal types.
slug: "dont-fall-5g8h"
tags: "#gamedev #unity #gameart"
---

Hi everyone!

I'm excited to announce that I've just published my new game on Google Play!

While there's nothing particularly complex about the development process to share right now, I did try something new on the technical side. I decided to experiment with [Microsoft App Center](https://appcenter.ms) for this project. Microsoft has created a nice SDK for mobile developers that provides an analytics dashboard and easy setup for push notifications (including basic audience targeting based on tracked events).

The only limitation I encountered is that the build system isn't fully compatible with Unity development yet. App Center allows you to build and distribute Android and iOS projects to stores, but it doesn't support custom setups for exporting builds from Unity to Xcode or Gradle projects.

I'm planning to work around this by using GitLab hooks to export the projects to Xcode and Gradle submodules, then push them to GitHub. This is necessary because App Center doesn't yet support GitLab as a repository sync option.

You can check out the game here: [Don't Fall on Google Play](https://play.google.com/store/apps/details?id=com.balconygames.dontfall)

I hope you'll find it to be a fun time-killer app!

Thank you for reading!

![screenshot1](https://thepracticaldev.s3.amazonaws.com/i/huqad1rsdby3e3aypfzt.png)
![screenshot2](https://thepracticaldev.s3.amazonaws.com/i/enbkz0r2sbu5rp8zwtjf.png)
![screenshot3](https://thepracticaldev.s3.amazonaws.com/i/6n43mbeyjjne4uoz1yhj.png)





Our new game published on Google Play and App Store.

Mobile Gaming Excellence: Building Engaging Casual Games for Mass Market Appeal

---
title: "Mobile Gaming Excellence: Building Engaging Casual Games for Mass Market Appeal"
date: "2019-02-14"
description: Our new game published on Google Play and App Store.
slug: "crystal-blast-9g1"
tags: "#gamedev #unity #startup"
---

Hi everyone!

A few days ago, we published our new game. No ads, no payments - it's all about the fun! We're still facing some technical challenges as game development is a new area for us.

We're hoping the community might be able to help us solve an issue we can't handle on our own.

We're using Unity, which is an awesome platform for rapidly prototyping games across multiple platforms.

## The Issue We're Facing:

For our other game ([Sweety Jumper](https://play.google.com/store/apps/details?id=com.balconygames.sweetyjumper)), we added in-app purchases and Google Ads packages to the Android build. While it compiles successfully, after installation on Android devices, the ads don't display and it's impossible to make purchases in either production or beta testing modes. Interestingly, the iOS version works perfectly fine.

Has anyone experienced similar issues when building for Android from Unity? We suspect it might be related to JAR dependencies in the APK build process, but we're not sure how to resolve it.

Any suggestions on how to properly debug this would be greatly appreciated!

## Our New Game

Our latest release is [Crystal Blast](https://play.google.com/store/apps/details?id=com.balconygames.CrystalBlast)

## Support Us on Product Hunt:
- [Upvote Sweety Jumper](https://www.producthunt.com/posts/sweety-jumper)
- [Upvote Crystal Blast](https://www.producthunt.com/posts/crystal-blast)

If you have time, please try our game and leave a review. We would really appreciate it!

Thank you for reading!

![image1](https://thepracticaldev.s3.amazonaws.com/i/f9nezuzng1584d0ohjye.png)
![image2](https://thepracticaldev.s3.amazonaws.com/i/wxe01vj66150r979iz2o.png)
![image3](https://thepracticaldev.s3.amazonaws.com/i/gggekuxlcwesvp4michr.png)
![image4](https://thepracticaldev.s3.amazonaws.com/i/qgxvnpq8cy2rojhcqvzr.png)
![image5](https://thepracticaldev.s3.amazonaws.com/i/1bncnwcm9lo6qmho4y0s.png)


Discover how to use UnityWebRequest for your REST API. Learn about the development process and the benefits of using UnityWebRequest for your REST API.

Enterprise Unity Development: Implementing Robust REST API Integration Strategies

---
title: "Enterprise Unity Development: Implementing Robust REST API Integration Strategies"
date: "2019-01-03"
description: "Discover how to use UnityWebRequest for your REST API. Learn about the development process and the benefits of using UnityWebRequest for your REST API."
slug: "how-to-use-unitywebrequest-for-your-rest-api-23e0"
tags: "#unity #restapi #webgl"
---

When I started working with Unity, my goal was to create a cross-platform game that could be deployed across multiple platforms: App Store, Google Play, Amazon, Facebook, Web, and Chrome Extension. While this approach sounds great in theory, it requires careful consideration of the libraries you plan to use.

Initially, I decided to use [HttpClient](https://assetstore.unity.com/packages/tools/network/http-client-79343) based on the `System.Net` namespace. However, when compiling to WebGL, I discovered that `System.Net` and `HttpClient` were excluded from the build, breaking the connection between my game and API.

The solution? Use `UnityWebRequest`.

Below are examples of how to build GET and POST requests with JSON using UnityWebRequest.

```C#
using System;
using System.Collections.Generic;
using UnityEngine.Networking;
using System.Collections;
using Newtonsoft.Json;
using UnityEngine;
using System.Text;

namespace Jumper.Network
{
    public abstract class API
    {
        // TODO: add https certificate verification
#if UNITY_WEBGL
        // WebGL version is loaded by browser under https protocol.
        public const string HOST = "https://api.example.com/client/";
#else
        public const string HOST = "http://api.example.com/client/";
#endif

        public static readonly string TOKEN_QUERY_PARAM = "?token=";
        public static readonly string REGISTER_PATH = "users/register";

        private const string USER_ID_KEY = ":user_id";

#region internal methods for http client
        internal static string path(string path, Dictionary<string, string> properties)
        {
            // In case the user has no user_id (possibly due to missing internet connection on boot)
            // we should use the /games namespace for sending requests.
            if (properties.ContainsKey(USER_ID_KEY) && !string.IsNullOrEmpty(properties[USER_ID_KEY]))
            {
                return resolve(
                    GAME_PATH + "/:game_id/sessions/:user_id/" + path + TOKEN_QUERY_PARAM + ":token",
                    properties);
            }

            return resolve(
                GAME_PATH + "/:game_id/" + path + TOKEN_QUERY_PARAM + ":token",
                properties);
        }

        internal static string resolve(string path, Dictionary<string, string> properties)
        {
            foreach(var kv in properties)
            {
                path = path.Replace(kv.Key, kv.Value);
            }

            return path;
        }

        internal static string requestError(UnityWebRequest request)
        {
            string responseBody = string.Empty;
            if (request.downloadHandler != null)
            {
                responseBody = request.downloadHandler.text;
            }

            return string.Format(
                "[api#error] request status code: {0}, data: ======= response: {1}, error: {2} =======",
                request.responseCode, responseBody, request.error);
        }

        internal static T requestResponse<T>(UnityWebRequest request)
        {
            try
            {
                var responseData = request.downloadHandler.text;
                return JsonConvert.DeserializeObject<T>(responseData);
            }
            catch (Exception ex)
            {
                Debug.Log(ex.Message);
                return default(T);
            }
        }

        public const string CONTENT_TYPE_JSON = "application/json";

        /// <summary>
        /// Create the instance of authenticated http client.
        /// </summary>
        /// <returns>The client.</returns>
        internal static IEnumerator Request(string url, string method, string data = null, Action<UnityWebRequest> done = null)
        {
            UnityWebRequest request;

            switch(method)
            {
                case UnityWebRequest.kHttpVerbGET:
                    request = UnityWebRequest.Get(url);
                    yield return request.SendWebRequest();
                    done?.Invoke(request);
                    break;
                case UnityWebRequest.kHttpVerbPOST:
                    request = UnityWebRequest.Post(url, data);
                    request.method = UnityWebRequest.kHttpVerbPOST;
                    request.downloadHandler = new DownloadHandlerBuffer();
                    request.uploadHandler = new UploadHandlerRaw(Encoding.UTF8.GetBytes(data));
                    request.SetRequestHeader("Content-Type", CONTENT_TYPE_JSON);
                    request.SetRequestHeader("Accept", CONTENT_TYPE_JSON);
                    yield return request.SendWebRequest();
                    done?.Invoke(request);
                    break;
            }
        }

        internal static IEnumerator Post(string url, object o, Action<UnityWebRequest> done = null) =>
            Request(url, UnityWebRequest.kHttpVerbPOST, JsonConvert.SerializeObject(o), done);

        internal static IEnumerator Get(string url, Action<UnityWebRequest> done = null) =>
            Request(url, UnityWebRequest.kHttpVerbGET, null, done);

        internal static Action<T1, T2> wrapCallback<T1, T2>(Action<T1, T2> doneCallback)
        {
            // In case of having a missing done callback, use an empty function
            // to avoid null checks when invoking the callback.
            return doneCallback ?? ((_arg1, _arg2) => { });
        }
    }
#endregion
}

```C#
// Example of using Api.cs

using Newtonsoft.Json;
using UnityEngine;
using System.Collections.Generic;
using System;
using System.Collections;

namespace Jumper.Network
{
    public class Users : API
    {
        public static IEnumerator Create(
            Dictionary<string, string> properties, User user,
            Action<User, string> doneCallback = null)
        {
            var done = wrapCallback(doneCallback);

            try
            {
                return Post(path(REGISTER_PATH, properties), user,
                    (request) =>
                    {
                        if (request.isNetworkError || request.responseCode != 201)
                            done(null, requestError(request));
                        else
                            done(requestResponse<User>(request), null);
                    });
            }
            catch (Exception ex)
            {
                // Catch all exceptions to ensure the application never crashes
                Debug.Log(ex.Message);
                done(null, ex.Message);
            }

            return null;
        }
    }
}

```C#
// Example from MonoBehaviour

StartCoroutine(Users.Create(
                Api.GameProperties, Api.CurrentUser, (user, err) =>
                {
                    if (err != null)
                    {
                        Debug.LogError(err);
                    }
                    else
                    {
                        // good to go
                    }
                }));
```


Discover how I am using Kubernetes for game development. Learn about the development process and the benefits of using Kubernetes for your game development.

Scaling Game Infrastructure: Why Modern Game Studios Choose Kubernetes Architecture

---
title: "Scaling Game Infrastructure: Why Modern Game Studios Choose Kubernetes Architecture"
date: "2019-01-03"
description: "Discover how I am using Kubernetes for game development. Learn about the development process and the benefits of using Kubernetes for your game development."
slug: "why-i-am-using-kubernetes-for-gamedev-2n14"
tags: "#docker #kubernetes #unity #gamedev"
---

Hi everyone!

It's a great time to share a post about an exciting new area I've been learning and building in. Game development has always been my goal since I started learning software development, but for various reasons, I've always been busy with other projects.

But enough about the past. Kubernetes is a truly exciting technology that I discovered while working as a solo developer on my backend and frontend projects.

## My Current Stack

- [DigitalOcean](https://digitalocean.com) - A hosting platform with reasonable pricing that's perfect for my indie projects. I want to thank the company for always being open to help, providing credits, and offering competitive prices.

- [Containership.io](https://containership.io) - A fantastic platform for provisioning Kubernetes on DigitalOcean. (I don't have any credits from them, but their platform has saved me significant time). While DigitalOcean now provides Kubernetes out of the box, I found it challenging as a beginner, especially when dealing with pods, services, and SSL certificate setup. This might just be my experience - I had better luck when I had full access to Kubernetes.

- [Kubernetes](https://kubernetes.io) - It's not just about microservices. Think of it as Heroku but with complete control through simple recipes.

- [Gitlab](https://gitlab.com) - A source control platform with free container registry for each repository.

## What My Cluster Hosts

- [https://api.balconygames.com](https://api.balconygames.com) - A Go server communicating with PostgreSQL (3 replicas)
- [https://dashboard.balconygames.com](https://dashboard.balconygames.com) - A ReactJS admin dashboard for game management (nginx + static)
- [https://sweety-jumper.balconygames.com](https://sweety-jumper.balconygames.com) - A Unity game (nginx + static) currently in development mode due to network issues
- [https://balconygames.com](https://balconygames.com) - Jekyll site (nginx + static)
- PostgreSQL (deployed using helm recipes)
- Letsencrypt for monitoring SSL certificates and creating new ones

The entire setup costs me about **$40** per month (3 nodes at **$10** each plus 1 Node Balancer), which is remarkably affordable for these resources.

## My Workflow as a Solo Backend Developer

1. Make code changes
2. Rebuild the image and push to Gitlab registry
3. Run `kubectl apply -f recipe/<name of the app>/deployment.yml` which contains `<image_name>:latest` or `<image_name>:$COMMIT_TAG`

My next step is to move this process away from my local machine and use Gitlab pipelines instead. This setup is easy to support and deploy, and it saves me valuable time.

If I ever need to set up Redis or other databases, I'll use the helm tool with predefined recipes to create pods, services, and deployments.

**Our game is [Sweety Jumper](https://play.google.com/store/apps/details?id=com.balconygames.sweetyjumper)**


Game development is another side of software development

Mastering Game Development Complexity: Strategic Approaches to Interactive Entertainment

---
title: "Mastering Game Development Complexity: Strategic Approaches to Interactive Entertainment"
date: "2019-01-02"
description: "Game development is another side of software development"
slug: "game-development-is-hard-1bpc"
tags: "#gamedev #unity #gameart"
---

Over the past few weeks, my friends and I have been working on creating a game from scratch in our free time, despite having no prior experience in this area. Let me share how it all began.

My friend and I were sitting in a nice bar, enjoying some cool wines. We were talking about life after 30 and reminiscing about the awesome times we had playing console games when we were younger. These days, we rarely have enough time to play. I'm a backend developer, and he was working as a developer for accounting software (though he recently started learning JavaScript and found his first job in frontend development). I told him about my school days when I learned Macromedia Flash to build small games.

Then my friend Igor said:

"You know, I have a friend named Vitaly who works in a grocery shop but also wants to build games."

And that's how it started. Three people from completely different backgrounds coming together.

We decided to use Unity because it seemed like the fastest way to build a game these days.

I focused on the backend part and developing an HTTP client for Unity to communicate with the server.

Our journey looked something like this:

0. What's the idea for the game? After talking with friends and drawing inspiration from tutorials, we settled on a concept and decided to build it into a product.
1. Where to get assets? This was challenging, but we searched the Unity store. Thanks to Black Friday prices, we spent $45 and got a UI asset package.
2. Where to get player assets? We searched online, found suitable assets, contacted the owner, got approval, and updated the info popup in the game.
3. Test, test, and test again.
4. How to earn money? We added in-app purchases and an option to watch ads to continue playing, but we designed it so it doesn't break the gameplay. You can still enjoy the game without spending money, and the ads aren't intrusive.
5. Get feedback. We implemented gyroscope controls, but based on feedback, we might need to change this approach.
6. Currently, our game is available on Google Play: [Sweety Jumper - Android](https://play.google.com/store/apps/details?id=com.balconygames.sweetyjumper).
7. We don't have a marketing budget or ads to promote the app yet. This would require more investment, but hopefully, if people like it, word-of-mouth might be enough!
8. I would recommend using gameanalytics.com to track your users (DAU, MAU) - at the very least, you'll have statistics about your players.

In future articles, I'll try to describe the main challenges beginners face when using Unity and getting started with game development.

Our Games (hopefully more than one in the future!):
[Sweety Jumper - Android](https://play.google.com/store/apps/details?id=com.balconygames.sweetyjumper)

Social Media:
[Twitter](https://twitter.com/balconygames)
[Instagram](http://instagram.com/balconygames)
[Facebook](http://facebook.com/balconygames)
[Website](https://balconygames.com/)

Screenshots:

![screenshot](https://thepracticaldev.s3.amazonaws.com/i/e8wsylpe0lw7pm8zp12a.png)
![screenshot](https://thepracticaldev.s3.amazonaws.com/i/xb6volcz6f1wajqbswof.png)
![screenshot](https://thepracticaldev.s3.amazonaws.com/i/c9tl6acvew8h2c58v8to.png)
![screenshot](https://thepracticaldev.s3.amazonaws.com/i/200xo7ljggeseg95i2rv.png)




Discover how to write test cases for your Apache Logstash filters. Learn about the development process and the benefits of using RSpec for your Logstash filters.

Enterprise Data Processing: Test-Driven Development for Logstash Pipelines

---
title: "Enterprise Data Processing: Test-Driven Development for Logstash Pipelines"
date: "2018-08-09"
description: "Discover how to write test cases for your Apache Logstash filters. Learn about the development process and the benefits of using RSpec for your Logstash filters."
slug: "write-test-cases-for-your-apache-logstash-filters-ah3"
tags: "#logstash #rspec #docker #ruby"
---

About a year ago, I started working on an ELK (ElasticSearch, Logstash, Kibana) setup for a BI platform. While processing events in Logstash, I found it frustrating to work with filter changes, especially when dealing with complex regular expressions, structures, or conditions.

Having extensive experience in Ruby on Rails development, I decided to leverage RSpec test cases to cover my Logstash filters. This approach made sense since Logstash uses JRuby internally for its packages and extensions.

I also wanted to containerize everything with Docker to avoid installing Logstash and gems on my local machine.

Let's start with the Dockerfile and then build out the project structure step by step.

```Dockerfile
FROM logstash:2.4

# Install Rspec related dependencies
RUN logstash-plugin install --development

# Install prod dependencies
RUN logstash-plugin install logstash-filter-prune

ARG ES_PLUGIN=logstash-output-elasticsearch-6.2.4-java.gem
ARG KAFKA_PLUGIN=logstash-input-kafka-7.0.0.gem

COPY gems/${ES_PLUGIN} /tmp/${ES_PLUGIN}
RUN logstash-plugin install /tmp/${ES_PLUGIN}

COPY gems/${KAFKA_PLUGIN} /tmp/${KAFKA_PLUGIN}
RUN logstash-plugin install /tmp/${KAFKA_PLUGIN}
```

The `gems/` directory contains frozen gem versions for our Logstash setup.

For a more efficient way to run test cases, let's define a Makefile:

```Makefile
NAME = your_logstash

build:
	docker build -t $(NAME) .
.PHONY: build

clean:
	docker rmi --force $(NAME)
.PHONY: clean

test:
	@docker run --rm -t -i \
		-v `pwd`/../:/app \
		-w /app \
		$(NAME) \
		/bin/bash -c "rspec /app/logstash/spec/$(TEST_CASE)"
.PHONY: test

console:
	@docker run --rm -t -i \
		-v `pwd`/../:/app \
		-w /app \
		$(NAME) \
		/bin/bash
.PHONY: console
```

- `make test` runs RSpec inside your container
- `make console` opens an interactive terminal inside the Docker container for manual execution and debugging (using `binding.pry`) of your specs

Now, let's create our `spec/spec_helper.rb`, which forms the foundation of our RSpec setup:

```ruby
require "logstash/devutils/rspec/spec_helper"
require 'rspec'
require 'rspec/expectations'

require 'ostruct'
require 'erb'
require 'yaml'
require 'json'

# Running the grok code outside a logstash package means
# LOGSTASH_HOME will not be defined, so let's set it here
# before requiring the grok filter
# (coming from the original examples for logstash specs)
unless LogStash::Environment.const_defined?(:LOGSTASH_HOME)
  LogStash::Environment::LOGSTASH_HOME = File.expand_path("../", __FILE__)
end

module Helpers
  ROOT_PATH = File.dirname(File.expand_path(__FILE__))
  TEMPLATES_PATH = File.join(ROOT_PATH, '..', 'conf.d/')

  def load_fixture(filename, settings = {})
    message = File.read(File.join(ROOT_PATH, 'fixtures', filename))
    settings.merge('message' => message)
  end

  def load_filter(filename, render_vars = {})
    content = File.read(File.join(TEMPLATES_PATH, filename))

    render_vars = OpenStruct.new(render_vars)

    # This isn't the most elegant solution, but it's the simplest way to handle
    # Jinja2-style variable replacement
    template = ERB.new(content.gsub('{{', '<%=').gsub('}}', '%>'))
    template.result(render_vars.instance_eval { binding })
  end
end

require "logstash/filters/grok"
```

In my Logstash filters, I use Jinja2-style syntax (`{{ }}`) for variable replacement, which gets handled by Ansible during deployment.

Now we're ready to define an actual spec to test our Logstash filter. Let's assume we want to parse a line like `username=<username>`. We'll create a `filter_spec.rb` file inside the `spec/filters` folder. Filters should focus solely on processing logic, not input or output statements.

```ruby
require_relative '../spec_helper'

describe 'elb' do
  extend Helpers

  # Set config using our defined filter in `conf.d/01-filter.conf` file
  config load_filter('01-filter.conf')

  # You can define in spec/fixtures/sample1.txt
  # Example: username=oivoodoo
  sample(load_fixture('sample1.txt', 'type' => 'your-source-data')) do
    insist { subject.get('username') } == 'oivoodoo'
  end
end
```

And here's our filter configuration:

```conf
filter {
  if [type] == "{{ type }}" {
    grok {
      match => {
        "message" => [
          "%{WORD:username}"
        ]
      }
    }

    prune {
      blacklist_names => [
        "@version",
        "message"
      ]
    }
  }
}
```

This approach has proven extremely valuable for saving time compared to deploying changes and waiting for new data. It's also easy to add a `ruby` filter inside your configuration and use `binding.pry` to inspect the `event` object during debugging.


Learn how to automate invoice generation using Python and Wunderlist API. This tutorial shows how to track billable hours in Wunderlist tasks and generate CSV reports for invoicing clients based on time entries.

Freelance Automation: Streamlining Client Billing with API Integration

---
title: "Freelance Automation: Streamlining Client Billing with API Integration"
date: "2018-08-01"
description: "Learn how to automate invoice generation using Python and Wunderlist API. This tutorial shows how to track billable hours in Wunderlist tasks and generate CSV reports for invoicing clients based on time entries."
slug: "build-invoices-based-on-wunderlist-41op"
tags: "#python #freelance"
---

For the past 8 years, I've been working remotely on contract jobs. For clients who pay by the hour, I need to send invoices every two weeks. I tried various invoicing applications before eventually settling on Google Docs.

Then I discovered Wunderlist, a nice to-do list application. I created Shopping and TODO lists and began using it daily. It quickly became a habit for me to record tasks there. I realized it would be perfect for tracking my billable hours as well.

I use the following format for tracking time in tasks:

```
<hours> hours TASK-1
<minutes> minutes TASK-2
<days> days TASK-3
```

After a month of tracking my time this way, I wanted to download this data and calculate the hours I'd spent during the month. So I created a script to generate a CSV report of my hours.

```python
import wunderpy2

from dateutil import parser
from datetime import date
from csv import writer


ACCESS_TOKEN = '<WUNDERLIST_ACCESS_TOKEN>'
CLIENT_ID = '<WUNDERLIST_CLIENT_ID>'
PROJECT_BOARD = 'LIST_TITLE'
HOUR_RATE = 1


def __build_hour(task):
    '''
    Parses task titles in formats like:
        dict(title='1 hour CORE-1234')
        dict(title='5 hours CORE-4321')
        dict(title='1 minute CORE-1234')
    '''
    columns = task['title'].strip().split(' ')
    time, measure, task_id = columns
    if measure == 'hour' or measure == 'hours':
        hours = float(time)
    elif measure == 'minute' or measure == 'minutes':
        hours = float(time) / 60
    elif measure == 'day' or measure == 'days':
        hours = 24 * float(time)
    else:
        raise ValueError('Unknown time measure in task title: ' + task['title'])

    return dict(
        task_id=task_id,
        created_at=parser.parse(task['created_at']),
        hours=hours)


def __main__():
    api = wunderpy2.WunderApi()
    client = api.get_client(ACCESS_TOKEN, CLIENT_ID)
    board = [l for l in client.get_lists() if l['title'] == PROJECT_BOARD][0]
    active_tasks = [t for t in client.get_tasks(board['id']) if not t['completed']]
    report = [__build_hour(task) for task in active_tasks]

    estimated_earnings = sum([task['hours'] for task in report]) * HOUR_RATE
    print(estimated_earnings)

    with open(f"report-{date.today()}.csv", 'w+') as f:
        w = writer(f)
        rows = [[task['task_id'], task['hours'], task['created_at'].date()]
                for task in report]
        w.writerows(rows)

    for task in active_tasks:
        client.update_task(task['id'], task['revision'], completed=True)

    # TODO: make monthly output report to pdf file based on created_at field.


if __name__ == '__main__':
    __main__()

```



Discover how to test your REST API in VueJS. Learn about the development process and the benefits of using VueJS for your REST API testing.

Quality Assurance Excellence: Advanced REST API Testing Methodologies in Vue.js

---
title: "Quality Assurance Excellence: Advanced REST API Testing Methodologies in Vue.js"
date: "2018-04-11"
description: "Discover how to test your REST API in VueJS. Learn about the development process and the benefits of using VueJS for your REST API testing."
slug: "testing-rest-api-in-vuejs-5126"
tags: "#javascript #vue #vuejs #js"
---

I recently started working with `VueJS` to build dashboard prototypes for analytics at my company. The simplicity of `VueJS` has quickly made it my favorite tool for JavaScript application development. While `EmberJS` developers commonly use the Mirage library to stub API calls and generate response bodies, for `VueJS` I've found [vue-resource-mock](https://github.com/noru/vue-resource-mock) to be an excellent alternative.

Let me share some examples to demonstrate how to use this powerful library:

```javascript
// main.js
...
import VueResource from 'vue-resource'
import VueResourceMock from 'vue-resource-mock'
import MockData from './mock/data.js'

Vue.use(VueResource)

if (process.env.NODE_ENV === 'development') {
  Vue.use(VueResourceMock, MockData)
}
...
```

```javascript
// mock/data.js

const id = () => Math.floor(Math.random() * 100)

export default {

  ['GET */example'] (pathMatch, query, request) {
    let body = {
      collection1: [
        { id: id(), name: 'name1' },
        { id: id(), name: 'name2' },
      ]
    }

    return {
      body: body,
      status: 200
    }
  }
}
```

The best part is that your component code remains unchanged. Simply make HTTP requests as usual, and you'll receive the mocked data during development:

```javascript
...

      this.$http
        .get(`${process.env.API_HOST}/example`)
        .then(response => {
          let { collection1 } = response.body
          this.$store.commit('setCollection1', collection1)
        })
...
```


Discover how to deploy an Ember application to a Kubernetes cluster. Learn about the deployment process and the benefits of using Kubernetes for scalable web applications.

Cloud-Native Development: Strategic Ember.js Deployment on Kubernetes Infrastructure

---
title: "Cloud-Native Development: Strategic Ember.js Deployment on Kubernetes Infrastructure"
date: "2018-04-05"
description: "Discover how to deploy an Ember application to a Kubernetes cluster. Learn about the deployment process and the benefits of using Kubernetes for scalable web applications."
slug: "how-to-deploy-ember-app-to-kubernetes-2i2m"
tags: "#kubernetes #emberjs #javascript #docker"
---

As part of my unfinished project [observerio](github.com/observerio/observer-server), I was working on my first Ember dashboard. After completing the prototype, I decided to deploy it as a pod in a Kubernetes cluster on DigitalOcean. Why Kubernetes? It can save a lot of time if you're a solo developer without enough resources to support a non-profitable idea.

During my first deployment, I found it relatively easy to build a release version of the Ember app. However, when opening the dashboard in a browser, I discovered that my routing wasn't working properly. After searching for solutions online, someone suggested modifying the Nginx settings when serving the Ember app.

Here's the [Docker.release](https://github.com/observerio/observer-server/blob/master/web/Dockerfile.release) file used by the pod:

```Dockerfile
FROM alpine:3.6

COPY dist/ /app

WORKDIR /app

CMD ["tail", "-f", "/dev/null"]

```

I needed to figure out how to change the Nginx settings. Since I wasn't familiar with the internal workings of Kubernetes, my next step was to explore the containers running in the Kubernetes cluster. In the ingress pod I found the Nginx template used for serving my Ember pod.

[nginx.tmpl](https://github.com/kubernetes/ingress-nginx/blob/master/rootfs/etc/nginx/template/nginx.tmpl)

To ensure I was working with the same template as the installed ingress container, I copied [nginx.tmpl](https://github.com/observerio/observer-server/blob/master/deployment/app-deploy/ingress/templates/nginx.tmpl#L458) from the container and added the following configuration (at line 458):

```
{{ if and (eq $path "/") (eq $server.Hostname "observer.rubyforce.co") }}
            try_files $uri $uri/ /index.html?/$request_uri;
{{ end }}
```

Then changed ingress controller to use the new template via config map, example of [Deployment](https://github.com/observerio/observer-server/blob/master/deployment/app-deploy/ingress/03-deployment.yml#L67)

Probably it could be helpful for someone as well.

Thanks for reading!


Learn how to automate browser interactions using Python and Docker to scrape data from web dashboards without an API. This tutorial shows how to set up a containerized Chrome browser for web automation using Splinter and Docker.

Scalable Test Automation: Enterprise Browser Testing with Docker and Python

---
title: "Scalable Test Automation: Enterprise Browser Testing with Docker and Python"
date: "2018-04-03"
description: "Learn how to automate browser interactions using Python and Docker to scrape data from web dashboards without an API. This tutorial shows how to set up a containerized Chrome browser for web automation using Splinter and Docker."
slug: "browser-automation-using-docker-and-python-2j2o"
tags: "#python #selenium #docker"
---

A few weeks ago, I was working on a new report for a customer's game. The platform providing campaign reports didn't have a public API to generate reports on demand with any kind of developer access key.

However, it was possible to request these reports through their dashboard. While it might seem odd to rely on a UI for downloading such reports, it was the only way to access the customer's valuable data.

Let's define the requirements for this project:

- It should be a standalone Python script for easy execution and integration with existing ETL libraries
- It shouldn't require extra software on the server except for the Docker package (which is quite flexible)

Now we're ready to build something functional. In this post, I'll use specific libraries to access the Docker process due to the version of packages installed in CentOS (in my example).

My requirements.txt:

```
docker==2.1.0
splinter==0.7.7
timeout-decorator==0.3.3
```

[Splinter](https://splinter.readthedocs.io/en/latest/) is a nice library that wraps browser drivers for automating interactions with web pages.

Let's define a class for running a `Google Chrome` container. Later, we'll use it to access web pages via the `splinter` library.

```python
class _ChromeContainer:
    '''
    _ChromeContainer handles running a Chrome Docker container
    in the background.

    Requires Docker service on the machine to pull and run images.
    '''
    def __init__(self):
        self.__image_name = "selenium/standalone-chrome:3.10.0"
        self.__client = docker.from_env()

    def run(self):
        '''
        Starts up a Docker container with chromedriver and waits for it to reach running state
        '''
        client = self.__client

        self.container = client.containers.run(self.__image_name,
                                               detach=True,
                                               ports={'4444/tcp': None})

        @timeout_decorator.timeout(120)
        def waiting_up(client: docker.client.DockerClient, container):
            while True:
                container.reload()
                if container.status == "running":
                    break
                time.sleep(1)

        waiting_up(client, self.container)

    def quit(self):
        '''
        Kills and deletes the container
        '''
        self.container.kill()

    @property
    def public_port(self):
        container = self.__chrome_container.container
        return container.attrs["NetworkSettings"]["Ports"]["4444/tcp"][0]["HostPort"]
```

Now we're ready to use `splinter` and `_ChromeContainer` to automate our task.

```python
import timeout_decorator
import docker
from splinter import Browser


class Worker:
    def __init__(self):
        self.__chrome_container = _ChromeContainer()

    def process(self):
        self.__chrome_container.run()

        self.__web_client = Browser('remote',
                                    url="http://127.0.0.1:{}/wd/hub".format(self.__chrome_container.public_port),
                                    browser='chrome')

        # Example for login request:
        try:
            self.__login()
        finally:
            self.__web_client.quit()
            self.__chrome_container.quit()

    def __login(self):
        self.__web_client.visit("http://www.example.com/login")
        self.__web_client.fill('developer_session[email]', 'EXAMPLE_USERNAME')
        self.__web_client.fill('developer_session[password]', 'EXAMPLE_PASSWORD')
        button = self.__web_client.find_by_id('developer_session_submit')
        button.click()
```

This is just an example, and you can extend it with similar steps like `__login` in your `Worker` class to accomplish more complex automation tasks.

Thank you for reading! :)





Discover how to implement a TCP server and client in Elixir. Learn about the development process and the benefits of using TCP for communication between applications.

High-Performance Network Architecture: Building Scalable TCP Solutions with Elixir

---
title: "High-Performance Network Architecture: Building Scalable TCP Solutions with Elixir"
date: "2018-04-03"
description: "Discover how to implement a TCP server and client in Elixir. Learn about the development process and the benefits of using TCP for communication between applications."
slug: "elixir-tcp-server-example--foo"
tags: "#elixir #tcp #server #client"
---

This post is about an unfinished project called [observerio](github.com/observerio/observer-server) that I haven't had enough free time to complete recently.

I've been working on this project to enable real-time testing of different game strategies. The result is a project with an HTTP API, TCP server, Ember dashboard, and a core library based on Go (using xgo compilation for cross-platform support).

I'd like to share some examples that might be useful for others.

## Why Elixir?

If someone asked me why I chose Elixir for the backend, I'd find it hard to explain precisely. I was likely inspired by my previous experience at my startup [musicfeed](http://musicfeed.co/). Elixir has an elegant syntax, a supportive community, and excellent documentation. However, concepts like gen_server and other tools can be complex to understand if you're learning Elixir as your first programming language. While some might tell you that you don't need to learn Erlang to use Elixir, that's only partially true, though the number of Elixir libraries is growing rapidly.

## Project Architecture

I decided to use a TCP server and client to send variables and logs from mobile games via an internal SDK. When the TCP server receives variables or logs, it publishes messages through PubSub (gateway) to subscribed WebSocket handlers. If a WebSocket connection is active, it automatically publishes the changes to the Ember dashboard. This might sound more like a fun experiment than a production-ready solution, but I built it for enjoyment anyway!

Let's review the TCP server implementation (please feel free to suggest improvements, as this is open source):

[tcp.ex](https://github.com/observerio/observer-server/blob/master/lib/web/tcp.ex)

## Supervisors for TCP Server and Client

First, we define supervisors for the TCP server and client. The client supervisor is used to create communication between the WebSocket (via PubSub) and the TCP client:

```elixir
defmodule Web.Tcp.ServerSupervisor do
  use Supervisor

  def start_link do
    Supervisor.start_link(__MODULE__, [], name: :tcp_server_supervisor)
  end

  def init(_) do
    children = [
      worker(Web.Tcp.Server, [])
    ]

    supervise(children, strategy: :one_for_one)
  end
end

defmodule Web.Tcp.ClientSupervisor do
  use Supervisor

  def start_link do
    Supervisor.start_link(__MODULE__, [], name: :tcp_client_supervisor)
  end

  def start_client(token) do
    Supervisor.start_child(:tcp_client_supervisor, [token])
  end

  def init(_) do
    children = [
      worker(Web.Tcp.Client, [])
    ]

    # We use the `simple_one_for_one` strategy.
    # With this strategy, we define just a "template" for a child,
    # no process is started during the Supervisor initialization, only
    # when we call `start_child/2`
    supervise(children, strategy: :simple_one_for_one)
  end
end
```

## Server Worker

Next, we define the server worker and pass the module name `Web.Tcp.Handler` as the entry point for processing connected clients:

```elixir
defmodule Web.Tcp.Server do
  require Logger

  def start_link do
    Logger.debug("[tcp] starting server on port :#{_port()}")
    opts = [port: _port()]
    {:ok, _} = :ranch.start_listener(
      :tcp, _acceptors_size(), :ranch_tcp, opts, Web.Tcp.Handler, [])
  end

  def _port do
    String.to_integer Application.get_env(:web, :tcp_port)
  end

  def _acceptors_size do
    String.to_integer Application.get_env(:web, :tcp_acceptors_size)
  end
end
```

## Client Worker

Now we define a module that works as a worker for connected TCP clients. On initialization, it subscribes to a PubSub channel using the API key (per user). This allows it to receive messages from PubSub and send them back to the TCP client socket:

```elixir
defmodule Web.Tcp.Client do
  require Logger
  require Poison

  alias Web.Pubsub

  def start_link(token) do
    GenServer.start_link(__MODULE__, token, name: String.to_atom(token))
  end

  def init(token) do
    Pubsub.subscribe("#{token}:vars:callback")
    {:ok, %{token: token, messages: []}}
  end

  def handle_info(%{vars: vars}, %{token: token, messages: messages} = state) do
    Logger.debug("[tcp.client] received message: #{inspect(vars)}")
    message = _pack(token, "vars", vars)
    Logger.debug("[tcp.client] packed message: #{inspect(message)}")

    messages = messages ++ [message]

    Logger.debug("[tcp.client] begin send message: #{inspect(messages)}")
    state = token |> _get_socket |> _send_back(messages, state)
    Logger.debug("[tcp.client] done send message: #{inspect(messages)}")

    Logger.debug("[tcp.client] messages: #{inspect(messages)}")

    {:noreply, state}
  end

  def terminate(reason, status) do
    Logger.debug("[tcp.client] reason: #{inspect(reason)}, status: #{inspect(status)}")
    :ok
  end

  defp _send_back({:ok, socket}, messages, state) do
    :ok = _send(socket, messages)
    %{state | messages: []}
  end
  defp _send_back(:enqueue, messages, state) do
    %{state | messages: messages}
  end

  defp _send(s, []), do: :ok
  defp _send({socket, transport} = s, [message | messages]) do
    transport.send(socket, message)
    _send(s, messages)
  end

  def _pack(token, "vars", vars) do
    vars = vars
    |> Poison.encode!
    |> Base.encode64

    "v:#{token}:#{vars}\n"
  end

  defp _get_socket(token) do
    Logger.debug("[tcp.socket] search for socket, transport by token: #{inspect(token)}")
    response = case Registry.lookup(Registry.Sockets, token) do
      [{_, socket}] -> {:ok, socket}
      [] -> :enqueue
    end
    Logger.debug("[tcp.client] _get_socket: #{inspect(response)}")
    response
  end
end
```

## TCP Handler

The TCP handler registers the socket in the registry when it receives a connection and starts a new client worker to subscribe to the PubSub channel by API key, establishing communication between PubSub and the TCP client:

```elixir
defmodule Web.Tcp.Handler do
  require Logger

  alias Web.Pubsub

  @moduledoc """
  `Handler` waits for lines separated by \n (newline). If the handler doesn't
  see a newline, it accumulates data until it receives one.

  `Registry.Sockets` contains api_key -> socket records for easy communication
  from the dashboard page to TCP clients.
  """

  def start_link(ref, socket, transport, opts) do
    pid = spawn_link(__MODULE__, :init, [ref, socket, transport, opts])
    {:ok, pid}
  end

  def init(ref, socket, transport, _opts = []) do
    :ok = :ranch.accept_ack(ref)

    case transport.peername(socket) do
      {:ok, _peer} -> loop(socket, transport, "")
      {:error, reason} -> Logger.error("[tcp.handler] init receive error reason: #{inspect(reason)}")
    end
  end

  @timeout 5_000

  def loop(socket, transport, acc) do
    # Don't flood messages of transport, receive once and leave the remaining
    # data in socket until we run recv again.
    transport.setopts(socket, [active: :once])

    # Before proceeding with the receive block on messages, we should call
    # transport.messages() once to ping ranch
    {ok, closed, error} = transport.messages()

    receive do
      {ok, socket, data} ->
        Logger.debug("[tcp.handler] received data: #{inspect(data)}")

        acc <> data
        |> String.split("\n")
        |> Enum.map(&(String.trim(&1)))
        |> _process(socket, transport)

        loop(socket, transport, "")
      {closed, socket} ->
        Logger.debug("[tcp.handler] closed socket: #{inspect(socket)}")
      {error, socket, reason} ->
        Logger.error("[tcp.handler] socket: #{inspect(socket)}, closed because of error reason: #{inspect(reason)}")
      {:error, error} ->
        Logger.error("[tcp.handler] error: #{inspect(error)}")
      {'EXIT', parent, reason} ->
        Logger.error("[tcp.handler] exit parent reason: #{inspect(reason)}")
        Process.exit(self(), :kill)
      message ->
        Logger.debug("[tcp.handler] message on receive block: #{inspect(message)}")
    end
  end

  defp _kill(), do: Process.exit(self(), :kill)

  defp _process([], socket, transport), do: loop(socket, transport, "")
  defp _process([""], socket, transport), do: loop(socket, transport, "")
  defp _process([line, ""], socket, transport) do
    _protocol(line, socket, transport)
    loop(socket, transport, "")
  end
  defp _process([line], socket, transport), do: loop(socket, transport, line)
  defp _process([line | lines], socket, transport) do
    _protocol(line, socket, transport)
    _process(lines, socket, transport)
  end

  defp _protocol(line, socket, transport) do
    Logger.debug("[_protocol] line: #{line}")

    case line |> Web.Tcp.Protocol.process do
      {:verified, api_key} ->
        _register_socket(api_key, socket, transport)

        Web.Tcp.ClientSupervisor.start_client(api_key)

        Logger.debug("[tcp.server] transport should respond with OK")

        case transport.send(socket, "OK\n") do
          {:error, reason} ->
            Logger.error(inspect(reason))
          _ ->
        end
      {:error, reason} ->
        Logger.error("[tcp] #{inspect(reason)}")
      :error ->
        Logger.error("error on processing: #{inspect(line)}")
      _ ->
    end
  end

  def _register_socket(api_key, socket, transport) do
    Logger.debug("[tcp.handler] _register_socket token: #{api_key}")

    case Registry.register(Registry.Sockets, api_key, {socket, transport}) do
      {:error, {:already_registered, _pid}} ->
        Registry.update_value(Registry.Sockets, api_key, fn (_) -> {socket, transport} end)
      {:error, reason} ->
        Logger.error("[tcp] reason: #{inspect(reason)}")
      _ ->
    end
  end
end
```

## Protocol Handler

`Web.Tcp.Protocol` defines the parser and handler for commands passed via the TCP client:

Example commands:
```
l:logs:<base64 json messages>
i:vars:<base64 json variables>
v:api_key - client should pass api key to verify that we have a registered client
```

```elixir
defmodule Web.Tcp.Protocol do
  require Logger
  require Poison

  alias Web.Gateway
  alias Web.Db.Users

  @moduledoc """
    Server messages:

      - `l:logs`
        logs - should come as json array and encoded base64

      - `i:vars`
        vars - should come as json dictionary and encoded by base64

      - `v:api_key`
        api_key - should verify key using our registry

    Client messages:
      - `i:s:name:value` - var set by name value inside of app
  """
  def process("l:" <> <<api_key :: bytes-size(12)>> <> ":" <> logs) do
    Logger.debug("[protocol] api_key: #{api_key}, logs: #{inspect(logs)}")
    logs
    |> Base.decode64!
    |> Poison.decode!
    |> Gateway.logs(api_key)
  end

  def process("i:" <> <<api_key :: bytes-size(12)>> <> ":" <> vars) do
    Logger.debug("[protocol] api_key: #{api_key}, vars: #{inspect(vars)}")
    vars
    |> Base.decode64!
    |> Poison.decode!
    |> Gateway.vars(api_key)
  end

  def process("v:" <> <<api_key :: bytes-size(12)>>) do
    if Users.verify_key(api_key) do
      {:verified, api_key}
    else
      {:error, "not registered user with api_key: #{api_key}"}
    end
  end

  def process(_), do: :error
end
```

## Test Cases

Finally, here's a test case to review the basic expected behavior [tcp_test.ex](https://github.com/observerio/observer-server/blob/master/test/tcp_test.exs):

```elixir
defmodule Web.TcpTest do
  use ExUnit.Case
  doctest Web.Tcp

  alias Web.Db.Users

  require RedisPoolex
  require Logger
  require Poison
  require Tirexs.Query

  alias RedisPoolex, as: Redis

  setup do
    Redis.query(["FLUSHDB"])

    {:ok, api_key} = Users.register(%{email: "user1@example.com", password: "12345678"})

    port = Application.get_env(:web, :tcp_port)
    host = "127.0.0.1" |> String.to_char_list

    {:ok, socket} = :gen_tcp.connect(host, port, [active: false])
    {:ok, socket: socket, api_key: api_key}
  end

  test "should register user session", %{socket: socket, api_key: api_key} do
    :ok = :gen_tcp.send(socket, "v:" <> api_key <> "\n")
    {:ok, reply} = :gen_tcp.recv(socket, 0, 1000)
    assert reply == 'OK'
  end

  test "should bulk insert logs on tcp request", %{socket: socket, api_key: api_key} do
    :ok = :gen_tcp.send(socket, "v:" <> api_key <> "\n")
    :ok = :gen_tcp.send(socket, "l:" <> api_key <> ":" <> ([%{message: "testing1", timestamp: 123123123}, %{message: "testing2", timestamp: 123123123}] |> Poison.encode! |> Base.encode64) <> "\n")

    :timer.sleep(2000)

    assert {:ok, 200, %{hits: %{hits: hits}} = response} = Tirexs.Query.create_resource([index: "logs-#{api_key}", search: ""])
    assert Enum.count(hits) == 2
  end

  # TODO: add marker support to create separate sessions on multiple devices.
  # we could have separate dashboards for the different devices.
  test "should store vars on tcp request", %{socket: socket, api_key: api_key} do
    :ok = :gen_tcp.send(socket, "v:" <> api_key <> "\n")
    :ok = :gen_tcp.send(socket, "i:" <> api_key <> ":" <> ([%{name: "testing1", type: "string", value: "example"}, %{name: "testing2", type: "integer", value: "-1"}] |> Poison.encode! |> Base.encode64) <> "\n")

    :timer.sleep(2000)

    vars = Redis.query ["HKEYS", "#{api_key}:vs"]
    assert Enum.count(vars) == 4
    assert vars == ["testing1:type", "testing1:value", "testing2:type", "testing2:value"]
  end
end
```

In future posts, I'll share the modules for PubSub and Gateway implementation, which should be straightforward to understand.

This project was created for fun, so if you plan to use similar approaches in production, please proceed with caution. I don't work with Elixir daily, so there might be areas for improvement in this implementation.

Thanks for reading!


Transform Your Business With Custom Software Solutions

IT Consulting & Development Services

Custom Software Development

Mobile App Development

AI & LLM Development