DEV Community: Alexandr K

Build unsigned iOS ipa to install via Sideloadly!

Alexandr K — Wed, 05 Nov 2025 11:08:07 +0000

Recently during the development it would require to test Apple Enclave with public/private key generation, since we are using Expo / React Native. I wanted to have the close enough build to the real app and don’t deliver the app to TestFlight by reducing the amount of time for the development.

Yes, used claude code to make the script but anyway it worked well for me and decided to share it.

Justfile

# iOS Build Configuration
app_name := "PushUP"
workspace := "ios/${app_name}.xcworkspace"
scheme := "${app_name}"
configuration := "Release"
archive_path := "build/${app_name}.xcarchive"
export_path := "build/ipa"
bundle_id := "co.bitscorp.pushup"

# Default recipe - shows available commands
default:
    @just --list

# Deep clean (closes Xcode and cleans everything)
clean:
    #!/usr/bin/env bash
    set -e
    echo "🧹 Deep cleaning (closing Xcode)..."
    # Close Xcode if running
    killall Xcode 2>/dev/null || true
    sleep 2
    # Clean everything
    rm -rf build/
    rm -rf ios/build/
    rm -rf ios/Pods
    rm -rf ios/Podfile.lock
    rm -rf ~/Library/Developer/Xcode/DerivedData/${app_name}*
    echo "✅ Deep clean complete"

# Build without archiving (for testing)
build:
    #!/usr/bin/env bash
    set -euo pipefail
    echo "🔨 Building project..."
    # Source Xcode environment for Node binary
    if [ -f ios/.xcode.env.local ]; then
        source ios/.xcode.env.local
    elif [ -f ios/.xcode.env ]; then
        source ios/.xcode.env
    fi
    export NODE_BINARY
    xcodebuild build \
        -workspace {{workspace}} \
        -scheme {{scheme}} \
        -configuration {{configuration}} \
        -sdk iphoneos \
        -destination 'generic/platform=iOS' \
        -allowProvisioningUpdates \
        CODE_SIGN_STYLE=Automatic \
        ONLY_ACTIVE_ARCH=NO

# Archive the iOS app
archive:
    #!/usr/bin/env bash
    set -euo pipefail
    echo "📦 Creating archive..."
    # Source Xcode environment for Node binary
    if [ -f ios/.xcode.env.local ]; then
        source ios/.xcode.env.local
    elif [ -f ios/.xcode.env ]; then
        source ios/.xcode.env
    fi
    export NODE_BINARY
    xcodebuild archive \
        -workspace {{workspace}} \
        -scheme {{scheme}} \
        -configuration {{configuration}} \
        -sdk iphoneos \
        -destination 'generic/platform=iOS' \
        -archivePath {{archive_path}} \
        -allowProvisioningUpdates \
        CODE_SIGN_STYLE=Automatic \
        ONLY_ACTIVE_ARCH=NO


# Extract IPA from archive without code signing (for Sideloadly)
export-unsigned:
    #!/usr/bin/env bash
    set -euo pipefail
    echo "📱 Creating unsigned IPA from archive for Sideloadly..."
    if [ ! -d {{archive_path}} ]; then
        echo "❌ Archive not found at {{archive_path}}"
        exit 1
    fi

    # Find the .app in the archive
    APP_PATH=$(find {{archive_path}}/Products/Applications -name "*.app" -maxdepth 1 | head -n 1)
    if [ -z "$APP_PATH" ]; then
        echo "❌ No .app found in archive"
        exit 1
    fi

    APP_NAME=$(basename "$APP_PATH")
    IPA_NAME="${APP_NAME%.app}.ipa"

    echo "Found app: $APP_NAME"

    # Create Payload directory
    rm -rf {{export_path}}/Payload
    mkdir -p {{export_path}}/Payload

    # Copy .app to Payload
    cp -r "$APP_PATH" {{export_path}}/Payload/

    # Create IPA (which is just a zip file)
    cd {{export_path}}
    rm -f "$IPA_NAME"
    zip -r "$IPA_NAME" Payload
    rm -rf Payload

    echo "✅ Unsigned IPA created at {{export_path}}/$IPA_NAME"


# Full build: clean, archive, and export for Development
ios: build archive export-unsigned
    @echo "✅ Done at {{export_path}}"J

just ios

And then download Sideloadly! app for mac and install it to your iPhone by signing with your developer account.

Thank you for reading!

Full Stack Developer from bitscorp.co looking for new opportunities

Alexandr K — Tue, 04 Nov 2025 09:33:32 +0000

Hey everyone!

One of the developers from our team at bitscorp.co is looking for new opportunities. He's been working with us for a while and I can say he's a solid engineer who can handle both backend and frontend pretty well.

The stack he's comfortable with: Node, Go, Ruby on the backend side and React, React Native for the frontend. Pretty much full stack developer who can jump into any part of the project and deliver.

He's been working on different projects with us, from building APIs to mobile apps. Good experience with production systems, knows how to debug issues and ship features without breaking things.

If you're looking for someone who can work independently and doesn't need hand-holding for every task, he would be a good fit..

If you have something interesting or know someone who's hiring, feel free to reach out. You can contact through bitscorp.co or leave a comment here.

Thanks for reading!

Our portfolio:

https://balconygames.com

https://bitscorp.co

Catalan Verbs - mobile app

Alexandr K — Sat, 28 Dec 2024 15:55:10 +0000

Hello.

Couple days ago for my birthday I published the new application, developed it for fun and learning catalan because living close enough to Barcelona and it's really nice
language.

Tech stack: ReactNative, Scrapy, Python (to automate translations), Cursor (probably I should include it now because it's really increasing speed of the development)

Ready to master Catalan verbs? Download now:
📱 iOS: https://apps.apple.com/es/app/catalan-verbs/id6738144158
🤖 Android: https://play.google.com/store/apps/details?id=co.bitscorp.cat

CatalanLanguage #LanguageLearning #Education #ReactNative #TechInEducation

Learn Spanish Chrome extension

Alexandr K — Sun, 08 Sep 2024 17:14:56 +0000

Hello.

I've just published the new extension for google chrome. I developed so fast but it's really useful for me because of learning the last months Spanish in free time.

Learn Spanish

10 words for free daily to learn

and then I added whop integration to make one time lifetime payment to make the app unlimited words daily on each tab open.

Don't think it would be possible to monetize it anyway but I tried to make such in chrome extension payment for learning purpose anyway.

Thank you for reading!

React Native and OpenAI

Alexandr K — Mon, 10 Jun 2024 18:38:44 +0000

Hello.

I've just developed the simple application using OpenAI / ChatGPT and had a lot of fun and how easy it was.

App preview

I know the app is really joke but anyway I liked the ability to pass the image and ask the specific questions about it.

For me it's really the first experience and probably it's really too obvious for a lot of developers who are involved now in using AI models for their applications.

Lets see the communication function and it would be really clean enough what the app does.

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 the specific prompts to output the responses in json and pass the image to analyze it. Also I localized the app by using en, es, de, fr, ru languages and saying to ChatGPT to respond me in specific language and it works out of the box. it's really math magic. :)

Of course I will publish the app but the huge problem for now that it's really expensive to ask gpt-4-turbo and probably the app will stay for awhile and then I would need to disable it.

Would it be interesting for anyone to have the text-based guide on how we develop pushup.bitscorp.co mobile app for 2 weeks?

Alexandr K — Sun, 01 Oct 2023 13:53:56 +0000

Thinking about building a text-based course about how we developed a mobile app using ReactNative / Supabase / ChatGPT and then published it to the App Store and Google Play?

The app for a month got about 60+ users with no adverts (only organic traffic) and having daily 20–40 daily tracked sports activities for the current users daily.

I would say in iOS the sports apps have more organic traffic in my experience.

App Store
Google Play
Web

Push up | Mobile App

Alexandr K — Mon, 11 Sep 2023 13:35:11 +0000

Hello.

We published our pet project to improve health by daily habbits.

Actually it's only about push ups and squats. Invite your friend and start to do exercises together.

Simple enough idea migrated from google spreadsheets into the app.

Push Up

Hope it would help someone to improve their life style during the working day.

Optimizing Elixir Phoenix action with huge json response by responding by cached, gzipped values.

Alexandr K — Wed, 19 Jul 2023 08:43:59 +0000

Hello,

It's great to be back, and I'm excited to share the recent code changes I've implemented for my clients. We've been working on a mobile react native application that includes a wiki-like section, providing users with valuable step-by-step information to improve their health.

One of the challenges we faced was dealing with a massive JSON response, roughly 20MB in size, retrieved from a single endpoint during the app's loading process. While we could split API requests and load content on-demand, we also wanted to ensure that users could access the app offline, making a one-time load during the initial launch beneficial.

The loading process was taking around 6 seconds, depending on the internet speed, and I decided to implement a quick fix, particularly for the wiki endpoints.

In our Elixir environment, we found the perfect solution in the cachex library. This impressive library features a warmer module, which automatically refreshes cached data either on boot or after a specified ttl (time-to-live).

By integrating cachex into our system, we're now able to optimize the loading process, providing users with a smoother experience while still benefiting from offline accessibility. Stay tuned as I delve deeper into the caching practices that helped us enhance the performance of our Phoenix Controller actions with JSON responses.

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

Create cache.ex in the lib folder:

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

Add this warmer module to application.ex:

defmodule BlogApp.Application do
  @moduledoc false

  use Application

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

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

And now you are ready to integrate this cached, gzipped data in the Phoenix controller.

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

It’s a short but powerful speed-up. Also, I’ve just started to use it for the huge JSON files jsonrs.

Thank you for reading!

Available for consulting Elixir, Go, JS, and Big Data. Our website: bitscorp.co and my Github: github.com/oivoodoo, github.com/bitscorp

My other blog: https://dev.to/oivoodoo

Road to ecommerce via Gumroad :)

Alexandr K — Mon, 27 Dec 2021 22:11:34 +0000

Hi everyone!

I've just started to sell of my game arts and complete games based on Unity engine that it could be useful for someone. I decided to focus on building the new games and one more coming the next month for testing the audience in TD style.

But for now I need to capture some budget for the marketing the new game. Hope it will be possible to do it with wonderful platform Gumroad. I've just discovered how easy to create the products pages and start selling it.

Products:

Complete Game - Don't Fall

Examples:
https://play.google.com/store/apps/details?id=com.balconygames.dontfall
https://apps.apple.com/es/app/dont-fall-by-balcony-games/id1460842492

Examples:
https://play.google.com/store/apps/details?id=com.balconygames.snake

Game Art - Paint Swipe - this game I didn't finish it but I will polish and share the source code later as well.

Enjoy!

Thank you!

Alex.

Phoenix umbrella proxy application.

Alexandr K — Tue, 15 Jun 2021 09:40:08 +0000

Hey everyone!

It's really long time to take me to start writing again. I was really busy trying to make the games as part of my free time company balconygames :) Good progress but it's not so good enough for the market because of the user acquisition is so expensive.

Today I've decided to share the example of the proxy application for umbrella Phoenix, probably it would be useful for someone who has the same issues like code reloading, websocket support. It has 4 apps inside of apps/, proxy, web(phoenix), admin(phoenix), db(shared ecto project). No more words, going to share::

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

New version of Crystal Blast 2.0

Alexandr K — Mon, 20 Jul 2020 06:19:50 +0000

Hi everyone!

Finally, we have just published the new version of Crystal Blast - Google Play and waiting for review success in Crystal Blast - App Store.

We added the wonderful sound effects, more ways to earn coins (it's only about the monetization, we added for the players to fast grow their weapons, ships), leaderboard.

As part of this build, I started to use my own game server for collecting analytics, storing player game settings, leaderboard.

Working on cleaning up the server-side code and share with the community as a good entry point for indie game developers.

Stack:

Go
Redis
ClickHouse
NSQ
ansible + docker-compose as the fastest way to just deploy the app.

Thank you for reading!

Best regards,
Alexandr.

Started to build game server for indie developers

Alexandr K — Wed, 17 Jun 2020 13:50:44 +0000

For the last months I didn't write anything, isolation in the house, work and work. Searching for the new contracts to work in free time, it was a bit exhausting :) and I decided to build something new for me.

I've just started to work on generic purporse game server for indie developers. I have already implemented key, value storage, leaderboards, guest auth by device id and working on the social networking.

I know that nakame exists, but it's challenge to make my own server and apply it for the current games in the market. Crystal Blast starting from 2.1 release version would use own analytics platform and storage instead of Firebase.

Plan to go away for external tools like firebase, game services and have everything in house and in the same time as cheap as possible.

Planning to open source it in 2-3 months if the games in prod will work fine.

Update: Crystal Blast is going to have sounds, leaderboards, settings syncing between platforms by using social sign in.