4 заметки с тегом разработка

As an iOS engineer, for the most time in my career, I have been “transforming JSONs into beautiful UI”. Compared to backend development, handling large amounts of data and doing performance optimizations are not a typical part of our work. Of course, from time to time, performance does matter — especially to make the UI smooth, but the techniques are often different — such as reusing views or offloading expensive work from the main thread. Additionally, if we want the client to be thin, most of the heavy job is delegated to the server, for example, content ranking, search, filtering and so on.

However, sometimes you still have to perform some expensive operations on the client side — for example, because for privacy reasons you don’t want some local data to leave the device. It’s easy to accidentally make those parts of code extremely inefficient — especially if you haven’t built this muscle of quickly spotting potential complexity issues yet. Algorithms and data structures do matter — this is something I only truly realized only several years into my mobile career, and I still see this thing to be often overlooked in the industry. Of course, early optimization is not needed and may even do harm (see premature optimization), but even basic calculations can become performance bottlenecks that severely harm user experience.

There is only one way to solve it — embrace the basics — which means using appropriate algorithms and data structures for the task at hand. One real example that I always recall is a thing I built for one of my projects many years ago. For an invitation flow, I had to implement a contact merge feature where the data would come from three different sources — backend, social account and local iPhone address book. We wanted to combine contacts from these sources into one if they had any overlapping channels (phone numbers or emails). The result would be an array of contacts with all their channels, so there would be no duplicate channels for two different contacts.

At first, my naive approach was just to go one by one and see if in the remainder of the list any contact has overlapping channels with the current one, merge them if yes, repeat. This was needed because, for example, the last channel in the list could have two channels — one that would overlap with the current one, and the second one that could have appeared in the previous contacts which would mean having to go through the list again.

I implemented this, and it worked pretty reliably, here is the pseudocode:

func slowReliableSmartMerge(contacts: [Contact]) -> [Contact]  {
    var mergedContacts = contacts
    var results = [Contact]()
    var merged = true

    while merged {
        merged = false

        while !mergedContacts.isEmpty {
            var commonContact = mergedContacts.first!
            let restContacts = mergedContacts.dropFirst()


            for contact in restContacts {
                if contact.hasNoOverlappingChannels(with: commonContact) {
                } else {
                    merged = true
                    commonContact = Contact.mergedContactFrom(contact: commonContact, otherContact: contact)

        mergedContacts = results

    return mergedContacts

An experienced engineer would quickly spot the issue here, but plese bear with me for a minute. I tested this on my device which had roughly 150 local contacts, 100 friends on social media, and a couple dozen users from the server. It would finish in just a couple of seconds after showing a spinner — “not a huge deal” I thought and moved on to the next feature. Test devices had much fewer contacts, so it worked instantly there. Then a couple of weeks later we started getting some reports from the users that this spinner can take a minute or even longer. Suddenly I realized that the issue was related to complexity, and then I figured that the approach I had taken could actually hit the O(n^2) complexity — similar to the bubble sort.

I quickly discussed that with another engineer on a whiteboard, and we came up with hashmaps to optimize this significantly:

func smartMerge(contacts: [Contact]) -> [Contact] {
    var channelToContact = [String: Contact]()
    var contactToChannels = [Contact: Set<String>]()

    for contact in contacts {
        var mergedContact = contact

        for channel in contact.allChannels {
            if let matchingContact = channelToContact[channel] {
                if mergedContact !== matchingContact {
                    let mergedMatchingContact = Contact.mergedContactFrom(contact: matchingContact, otherContact: mergedContact)
                    contactToChannels[mergedMatchingContact] = (contactToChannels[mergedContact] ?? []).union((contactToChannels[mergedMatchingContact] ?? []))

                    if let channels = contactToChannels[mergedContact] {
                        for c in channels {
                            channelToContact[c] = mergedMatchingContact

                    contactToChannels[mergedContact] = nil

                    mergedContact = mergedMatchingContact
            } else {
                channelToContact[channel] = mergedContact

                if contactToChannels[mergedContact] != nil {
                } else {
                    contactToChannels[mergedContact] = [channel]

    return contactToChannels.keys

The eventual complexity was linear, the spinner would just flicker for a split second, and the tests were luckily green.

Since then, I’ve always been much more alert when it comes to doing some computation on the client side that potentially can have a variable-sized input. This all seems to be very obvious to me now, but back in the day this didn’t look too important to me. I think having a proper understanding of the complexity that comes with various algorithms and data structures can make you a much better software engineer which will lead to better products you build. After all, this is how the big tech companies hire — they value coding skills more than knowledge of certain frameworks.

These days, it’s also important for new folks who switch to software engineering from other areas — they often start their career with simple projects that involve UI work or simply connecting the stuff that’s built on top of well-known frameworks. I’d encourage them to also master the core things like algorithms in order to excel at this job.

Disclaimer: the ideas in this article are based purely on my personal experience working in big tech and smaller companies over the years and multiple conversations I’ve had with other people working in FAANG. Not all big companies out there do the things I describe here, and some smaller companies don’t adopt such practices either.

Smaller tech companies often get inspired by what the big companies like FAANG do — how they manage projects, organize the office space, hire the talent and write code. While it can be useful to leverage some of the best practices, I believe there are things that can actually bring harm if followed blindly. Let me describe several things that I find counterproductive in the small company environment but which are still often used because the grown-ups do it.

1. Interviewing

The traditional interview at a big tech company is a standard mix of coding, system design and behavioral sessions. This is what Cracking the coding interview book is about. Also, this is what leetcode is all about. As a result, lots of engineers try to get trained at solving algorithmic and data structure riddles, and then they never rotate trees nor find the shortest path between two nodes at work.

But does it have to be like that? Big companies do it this way because they value pure problem solvers that can adapt to any framework or tool — in big companies, it’s often an internal framework that’s not used anywhere else. There can also be teams that work on a new language or a new cutting edge technology. It’s believed that the person who can reliably solve algorithmic problems and understand the complexity also can perform well at any kind of programming job that they will face at work.

For smaller companies, what they usually need is work on a product that’s developed using a framework well-known in the industry. For this reason, interviews can totally be done as a test task that is much closer to the actual job. Pair programming sessions can work great too — especially if the goal is to find a teammate that would perfectly fit into a small team.

2. Building own tools and infrastructure

I’ve seen some smaller companies trying to deploy their own git or hg repos or set up fully custom CI pipelines. Big companies often build tools from scratch for the following reasons:

  • Such tools didn’t exist on the market when they already needed them.
  • They need some custom features that the majority of the market doesn’t care about.
  • They don’t want to depend on other services that can go down unexpectedly.

In my opinion, smaller companies shouldn’t spend too much time on re-inventing the solutions that already exist on the market. They can just compare those solutions and choose the one that provides all the necessary features, is reasonably priced and has a good reputation:

  • Do you need to store your code in a versioned system? Probably Github or Bitbucket are your best options.
  • Do you need a continuous integration system? Then maybe use Gitlab or Github’s CI functionality.
  • Maybe you need a mobile CI/CD pipeline? Use Bitrise or other specialized platforms.

Using an existing battle-tested service usually saves a ton of money and allows people to focus on the actual work.

3. Heavy process

Big companies introduce heavy process (such as required system design or product reviews) because of:

  • Their scale — when there is a long chain of people between let’s say a director of product and a product team, they want to make sure the individual team doesn’t go rogue and build something very different from the high-level vision.
  • Fear of shipping something wrong — this fear is even greater than the prospect of shipping a breakthrough, that’s why it often seems to be easier to introduce a process that’s supposed to protect against potential screw ups.
  • Paper trail — some people have to be kept accountable and responsible for the decisions.

All these things are not always needed in smaller companies where all the people usually know each other. In such an environment, it’s often reasonable to trust people over process. For example:

  • Two people on a project don’t need a daily stand-up — they can just informally sync throughout the day (maybe even async).
  • A product designer on a small project doesn’t have to take all the wireframes to a design review every time there is a change — instead, after there is an initial alignment, they can evolve the design independently.


I hope these ideas will help some teams look again at the way they work and try to think if they do actually need it to mimic what the big companies do — or they can get rid of things that make them unnecessarily slower and focus on what really matters more to them.

If this article gets enough traction, I will follow up with the list of three things that are used in big tech but for some reason are often overlooked in smaller companies.

20 февраля 2023, 17:59

What makes an app unbreakable

More than seven years ago I and my friends released Prbvlk — the iOS app that shows public transport departures in real time for Samara, our million-people home city. We released a major update in 2018 before the World Cup effectively making Stops the go-to app for our numerous city visitors, but since then we haven’t basically touched it at all. The app still has about 40K monthly active users on iOS and had around 65K on its best days even though Yandex was our competitor. But the locals still preferred Stops as it has always been more accurate, and was just done with a lot of nice touches.

Over the years, we’ve heard a lot of feedback from our amazing users, and I decided to finally update it by adding some long-awaited stuff — the new version is coming later this month. When I opened the repo, I was surprised that the app still builds on the latest Xcode, in addition to still working flawlessly after several major iOS and iPhone releases in a row, and the crash-free rate consistently being at >99.9% over the years. I have always taken it for granted for this app, but then I realized this is something I’ve never seen in my other apps at work.

So, I want to reflect a bit on what can make a mobile app this stable and put this into a list of recommendations that ultimately can make an app low-cost in terms of maintenance. I hope it can be useful for my future self when I build another app and for other software engineers too.

1. Simplicity

This is not a surprise, but the simpler the app, the fewer errors it should have, the lighter its maintenance cost is, and the lower effort needed to support it. Any feature or any extra layer of complexity usually adds more cost than you would originally think. It’s not just the amount of code that you add — it’s also more testing, more refactoring in the future, and more knowledge transfer if you add more people to the team. So, just don’t include features that are not necessary. Ask yourself if your users or yourself will truly benefit from it and if this is greater than the cost of supporting it.

Example: iPad version of the app

We inherited the bundle id from the local transport app that had been developed a long time ago but still had several thousand active users, and the previous maintainer offered this inheritance himself. We thought it would help us get more users quicker on the new shiny version. But it came with the iPad app flag in its App Store metadata which forced us to support a separate UI for tablets.

It definitely made it harder to iterate. The real question was: did we really need to support tablets in the app that is mainly used on the go? And even if some people did this, would the automatic compatibility mode be enough to cover it? If I had used a fresh bundle id, I would have never enabled the iPad capability — maybe only after several versions once we would finish all the core things and know tablets would unlock more opportunities.

Also, you may notice that even some iOS apps from big tech companies don’t support the native iPad UI. The reason is these apps are very complex, and having to support another screen size would slow them down dramatically.

2a. As few external dependencies as possible

This is similar to the previous tip about simplicity, but I want to point this out separately. Pulling libraries that do some tasks does come at a cost. For every library you are about to use, ask yourself if you can do the same on your own with a reasonable amount of effort. Some examples of popular pods to pull in iOS development that I considered back then:

  • Image caching — wasn’t available out of the box, so we had to include a third-party library.
  • Auto Layout syntax helpers — everything was provided by iOS SDK, so we didn’t need to pull another dependency here.
  • Crashlytics and analytics — we needed it to know about the crashes (App Store still didn’t give crash logs and stats) and user behavior to improve the app.
  • UI components like pull-to-refresh or bottom sheets — I didn’t pull them as all the UI could be done by myself.
  • Networking — it was so tempting to use the amazing AFNetworking library, and I pulled it in because I was using it for my work project then, however, it all could be done with URLSession, and now I’d probably just use the Apple framework.

The reason to avoid such bloat is you would have to own any dependencies you add, and they can go out of maintenance or will just become incompatible with your other frameworks or toolchain versions. In my case, after I run pod update, most of the stuff just worked, only Firebase had to be updated.

2b. Reliable backend, data, API

This is a continuation of the previous point, however, sometimes you don’t have a choice other than relying on a 3rd party service. In our case, we were fortunate to use the data from a reliable provider of raw data — the city transport operator via their API. But if you use another service API, keep in mind it can go out of business or can become paid which will mean you will have to close your app or change your monetization strategy.

Example: Uber integration

I thought it would be nice to add Uber integration in case there was no transport available (for example, at night), and I even had a separate branch where all the integration was almost complete. 

However, I still hesitated to add it because I thought it would still cover a very rare scenario, and people could prefer other taxi apps, not only Uber. Eventually, it turned out to be the right decision as Uber got out of business in Russia and was merged with Yandex, and their APIs and redirects into the Uber app just stopped working. So, to mitigate this I would have to either remove the feature or quickly build another integration that could also become useless at some point.

3. Rigorous Testing

It’s not a coincidence that testing teams are often called Quality Assurance. We made sure we tested manually a lot — at different times of the day (when there is no transport at night), without reliable connection (on the tube), and on various combinations of devices and OSes. We leveraged Testflight to invite as many beta testers as we could and opened various feedback channels to be able to react quickly. Even to this date, we still have a feedback form built into the app, and it served as a great source of wishes and bug reports.

4. People on the team and enthusiasm

This is not a technical tip but still an extremely important one. Eventually, we had a team of four people who enjoyed working on it, and we approached it with the highest quality bar possible. We did it for our city, and we, our families and friends would use the app every day. That’s why we wanted to make it as flawless as possible, and also have fun along the way. And it definitely paid off — we would gather in one of our flats on a Saturday night to fix the issues coming from testing, brainstorm some new ideas, or just polish something together.

iOS-specific bonus: Objective-C helped a lot

As we wrote the app in Objective-C, it basically works as is. If it was written a bit later when Swift came out, maybe around Swift 2 or 3, we would have to do a lot of changes just to support the latest Swift. So, maybe it’s worth using some established technologies and not relying on a framework that tends to change dramatically every several months. For example, a couple of years ago I would probably also avoid SwiftUI, but now it’s probably the right time to use it if you can target iOS 14 and above.


Of course, there is no silver bullet that would magically make your app stable and error-prone. For my app, these tips worked, and applying some of them where possible also helps me on other projects. I hope some developers will find this list useful to build a reliable app.

apple   ios   мобильная разработка   разработка

Innovation comes from trial and error. Scientific breakthroughs are often a result of countless experiments. The successful inventions are born out of countless attempts — just like the Edison light bulb.

It looks like the same principle can be applied to digital products. Luckily, in software we have a true luxury of being able to run experiments in production and learn from them without a huge cost overhead. Compare it with the construction business where a building can be built only once, then possibly tweaked just a little, and all the learnings can be applied only in the next project. However, in startups and small companies the experiments are surprisingly not that common — while in some large companies the whole established product can be an automated A/B-test machine. Let me share some points which should be kept in mind while doing experiments to ensure a successful outcome. I hope that even if you are not doing experiments now, you will see why they can be useful for you, and what to pay attention to.

1. Have a clear hypothesis

This is the most important tip. Don’t even start unless you have a clear understanding of what the proposed change should bring, and ideally what the action plan should be after the experiment concludes.

Good example:

If we reduce the amount of steps in the onboarding flow, more people will finish it and start using our service. If this turns out to be true, we will roll out the shorter flow.

Bad example:

If we redirect some of our app users to our website, more people will use our service.

Why bad: not really clear if more usage comes from the redirect itself — maybe it’s people who have to continue a critical task on web + there is no clear action plan — should we wind down the web version, should we prioritize the app, should we redirect on certain pages, etc.

2. Adjust for the stage of the product

If your product is rather established, you can run smaller experiments where each of them can move certain metrics. Then you iterate and gradually improve the whole thing. There is almost certainly no point in making drastic changes that can bring a lot of chaos in individual metrics.

If your product is still looking for product market fit, then basically every change can be big enough to steer the whole thing in a new direction, especially if there are not too many users. That means many decisions should be rather driven by your product vision and intuition, although you should still make informed decisions and measure the outcomes. And again, see the first point above — always have a clear hypothesis and an action plan.

3. Running a controlled experiment is better than not running it at all

Often some people on the team can be skeptical about some proposed changes, for example, having a new payment method can bring a lot of new purchases, however, this can be not enough to justify the flat fee that you’d need to pay for the integration. Running an experiment on a small number of users and proving it in a real life scenario is much more valuable than doing such projections, especially if the internal conversation seems to be stuck, and there is no clear path forward. If the implementation cost is not massive, probably the best move here is to get a buy-in from leadership and be clear about the hypothesis and the action plan depending on the outcome.

4. Have the right set up and tools

Always make sure that:

  • Test and control groups have consistent experience — i.e. a user from the test group will always have the test experience during the lifetime of the experiment.
  • Results are statistically significant — you can use some online tools to verify you get a proper result, not just random noise. Also keep in mind that the bigger the metric move you expect, the fewer participants you need to prove it — and vice versa.
  • Metrics are correctly calculated — meaning that you can reliably measure the outcome for the test vs control groups.

5. Be aware of other experiments that can affect your experiment results

Some experiments can be affected by external events — such as seasonality, or an operating system update, etc. Other experiments can lead to a different outcome because of other tests being run simultaneously. Try to avoid this by making the experiments either smaller or isolated from each other.


You introduce a new login screen, and also introduce Sign In with Google button.

Probably the best way here is to split into 4 independent groups (two-by-two: old/new login screen and with/without the Google button), and analyze accordingly.

6. Even negative results are a good learning

Sometimes people are afraid that their experiments can lead to worse results. I’d say this is still a positive learning because if the experiment was run in a controlled environment with a clear hypothesis, you don’t affect real users much, and most importantly now you know that some of your ideas won’t work out, and you can safely put it away until better times. Just treat it as a lucky scenario vs doing the same change because someone strongly believed in it and didn’t even run an experiment.

If all these points are taken care of, then hopefully the experiments should provide useful learnings to make your product better. Please share any interesting experiments you’ve run and what eye-opening insights they’ve brought.

Recently I’ve started writing more frequently about software engineering and mobile development in particular — mainly in English language — just to capture some thoughts that I find important, and some of them would hopefully be useful to other people too.
* * *
В последнее время я начал писать чаще об IT в целом и мобильной разработке в частности — в основном на английском языке — чтобы поделиться некоторыми мыслями, которые важны и интересны мне. Я надеюсь, что они будут также полезны и другим людям.