Meet Adem: your dedicated software engineering expert

Setting up a monitoring stack on the existing product.

• Configuration and deployment of a complete monitoring stack (Exporters, Prometheus, Grafana, AlertManager) on the existing product,
• Design of a data retention and long-term storage solution.

Implementation of best practices and improvements to the existing system.

• Python3.x service template with multiple targets and smooth development experience (Dev containers),
• Fully functional code quality checkers suite (isort, black, pylint, mypy),
• Advanced use of poetry,
• Optimized multi-stage containerization (docker).

Setting up a PoC around a new software quality control solution called 'CrystalClear'.

• Design of a docker services architecture exposing HTTP APIs,
• Deployment of the solution using docker-compose,
• Setting up a smooth development environment.

Getting started with Ray, a Python framework dedicated to optimizing available CPU and GPU resources.

• Studying the Ray framework documentation and its various components.
• Setting up a local development environment for Ray.
• Running simple Ray tasks and understanding the resource optimization capabilities of the framework.

Proposal of a simple software architecture around this framework, and integration of a video ingestion pipeline through it.

• Drawing up a simple software architecture that incorporates the Ray framework.
• Implementing a video ingestion pipeline using Ray tasks and actors.
• Testing and debugging the pipeline to ensure efficient video stream processing.

Improvement of 'code quality' tools on an internal library (integration of type-checking, linting, and automatic formatting via hooks and Github Actions).

• Integrating pylint and mypy for linting and type checking.
• Setting up pre-commit hooks for automatic code formatting using black.
• Configuring Github Actions to run the code quality tools on each commit.

Implementation of poetry (Python package manager) on existing services to improve their dependency management.

• Installation and configuration of poetry on existing services.
• Migration of existing dependencies to poetry's pyproject.toml file.
• Testing the build and deployment process with poetry.

Updating Boxy applications for better monitoring of store-related events (customer entry-exit, product pickup, etc).

• Upgrading existing applications to include real-time event tracking features.
• Implementing new logging and reporting functionality to monitor customer behaviors.
• Testing and troubleshooting to ensure accurate event tracking.

Adding temperature capture in Boxy and sending the information to our cloud infrastructures.

• Integrating temperature sensors within the store and programming them to capture data.
• Developing and deploying an IoT application to transmit temperature data to cloud-based storage.
• Setting up data visualization tools for temperature monitoring.

Design of Boxy v2: design of the new microservices architecture, use of robust technologies, upgrading the architecture to a solution more in line with existing standards.

• Planning and designing a new microservices architecture for Boxy v2.
• Selecting and integrating robust technologies to support the new architecture.
• Redesigning and upgrading the architecture to align with current industry standards.

Setting up 'code quality check' procedures for Python applications: linting, formatting, unit testing, and static type checking (all automated via Gitlab Git-Hooks).

• Implementing code quality tools such as pylint for linting, yapf for formatting, pytest for unit testing, and mypy for static type checking.
• Setting up automated pipelines using GitLab CI/CD to run these checks on every code push.
• Configuring Git-Hooks to trigger these pipelines automatically.

Design and development of an internal tool for creating and managing databases of images and videos.

• Creating a user-friendly interface for uploading and organizing image and video files.
• Implementing a database system for efficient storage and retrieval of media files.
• Developing backend logic for managing media metadata and associated annotations.

Improvement of internal annotation tools, changing the technical stack. Implementation of code review, pair programming sessions, etc.

• Upgrading annotation tools with newer, more efficient technologies.
• Establishing a code review process to maintain code quality and consistency.
• Implementing pair programming sessions to improve team collaboration and problem-solving.

Design and development of the Context product: a REST API for sending videos and receiving analysis (celebrity detections, logos, objects, etc.). API versioning, updating without service interruption.

• Designing and building a robust REST API for video upload and analysis retrieval.
• Implementing API versioning to maintain backward compatibility during updates.
• Ensuring seamless updates with zero downtime using blue-green deployment strategies.

Development of features on the client dashboard: number of videos loaded on the API, various statistics on videos, etc.

• Adding new features to the client dashboard for tracking video uploads and related statistics.
• Enhancing data visualization elements for a more intuitive understanding of video analytics.
• Ensuring seamless communication between the dashboard and the backend API.

Setting up functional tests for the API and dashboard.

• Implementing a suite of functional tests for the API using PyTest.
• Setting up front-end tests for the dashboard using Jest.
• Integrating these tests into the CI/CD pipeline for automated testing on every code commit.

Redesign of the core Context application: the 'Compute' service responsible for loading deep learning models and processing received videos: frame slicing, subsampling, detection, tracking, classification. Transition to a microservices architecture linked to a Kafka messaging service. Solving scalability issues of microservices via Kubernetes + addons.

• Refactoring the 'Compute' service to improve its efficiency and reliability.
• Transitioning the application to a microservices architecture for better scalability and maintainability.
• Integrating with a Kafka messaging service for efficient inter-service communication.
• Deploying the application on a Kubernetes cluster and resolving scalability issues with appropriate Kubernetes addons.