Developer for the Build and Test System Group

We are developing a build system inside a monorepository that provides static, hermetic, reproducible, and incremental building, testing, and packaging of source code in six languages (C++, Python 2/3, Java, Kotlin, Go, TypeScript) with support for cross-compilation and transparent interoperability between languages.

The build system consists of two parts:

ymake utility Written in C++, performs dependency analysis and creates a build graph — determining what and in what order code needs to be built.

Our team Develops the ya-bin and test_tool utilities, written in Python 3, and provides a user CLI (command-line interface), launches build commands, supports isolation, ensures interaction with testing frameworks for different programming languages, and aggregates results.

About the team

There are five of us, we are a geographically distributed team — we communicate via Zoom, meet offline every six months, and discuss the past, present, and future of our product.

We have daily stand-ups, weekly planning, architecture discussions, and rotating weekly on-call duties — not at night and not on weekends (except for some critical issues, but there is no need to be on call).

Our work is mostly project-based, involving maintaining baseline quality and potentially taking on reasonably urgent and important tasks. At the beginning of a season, we choose which requests to work on, and at the end of the season, we present the results. Each team member is responsible for one or several projects.

For example, recently we: * Enhanced the telemetry service for the CLI application, and now we have metrics and alerts — we react quickly if something goes wrong. * Added linters to our build system. Now developers can run linters and manage their configuration uniformly. * Accelerated the build by improving the service for distributed caching of build artifacts. * Accelerated integration testing through the background local launch of heavy services. Traditionally, we focused on test isolation and reproducibility and therefore launched services for each test suite, which significantly slows down testing. We want to rework the architecture and allow sacrificing hermeticity for the sake of getting test signals faster.

We investigate developer pain points and their requests regarding our product to reduce the cognitive load when working with our tools.

What tasks await you

Development of the build and test system model Our build system builds and tests millions of lines of code in different languages, each with its own specifics and infrastructure. It is important for us to carefully choose solution options, avoid increasing technical debt, and maintain consistent behavior with existing capabilities.

Writing efficient algorithms Our product runs hundreds of thousands of times on various machines, and a build can last from seconds to several hours. Under such conditions, it is crucial for us not to slow down people's work and release processes, so our algorithms must work efficiently. And for their efficiency to grow, they must be understandable for future generations.

Working with users We make a product for people — this means we listen to our users and pay attention to feedback. And sometimes politely disagree. For us, it is important to propose solutions based on an understanding of systems and formulate directions for development towards systemic solutions.

Supporting guarantees The build system is the foundation of infrastructure: release processes, incremental builds, and testing. This imposes certain requirements on us. We want the resulting artifact or test to work the same regardless of the machine on which it was built and run. To achieve this, we write cross-platform code, monitor the functional compatibility of compilation and cross-compilation results, and prevent the environment from 'leaking' into our build.

More about backend at Yandex — in the channel Yandex for Backend

We expect that you

• Have a sufficient level of understanding of Python: basic syntax, asymptotics, Pythonic code, typing, concurrency model
• Can and are willing to write tests
• Are ready to take on projects lasting a quarter or half a year and see them through to completion
• Enjoy teaching and learning, documenting your knowledge, and passing it on
• Are communicative, ready to communicate within the team and in the context of support
• Are not afraid to take responsibility for your mistakes and correct them
• Can manage your time, rest on time, and avoid overworking

It will be a plus

• You have a good level of knowledge of C++, Java, Go, Kotlin
• Have worked with high-load systems
• Have worked with monorepository build systems: Bazel, Buck, Pants, Please
• Have worked with source code build systems: Make, CMake, and others
• Know graph theory
• Know the basics of working on different operating systems and their differences
• Have written cross-platform code