Vasil Velikov

The computational complexity of the seemingly simple task of finding a return trip from point A to point B is immense. The evolution of the air travel industry has made the search for possible flights and prices intractable. This project attempts to address this complexity with a mixture of heuristic and caching techniques. The core of the search engine is based on various heuristic graph algorithms used to navigate through the search space. An upper layer of the engine aggressively precomputes and caches hundreds of gigabytes of data in NoSQL databases.

I oversaw the delivery of the project.
My responsibilities included:
- building the project roadmap and ensuring its delivery
- resource allocation
- definition of and adherence to the internal Agile processes
- release and deployment management
- active participation in technical and architecture designs
- active participation in code reviews
- delivery of core features

The technologies used were:
- modern C++, Python
- several SQL and NoSQL databases
- Linux, Git
- virtualization and distributed computing

A key difference between C++ and most modern languages is the lack of reflection - the ability to perform runtime introspection and method invocation. The main reason for that is the core philosophy of C++ - "you don't pay for what you don't use." Reflection, however, has several useful applications even in the context of C++:

My responsibilities included:
- automatic serialization and deserialization
- automatic building of API bindings for other languages
- in-depth code analysis

The purpose of this project was to create a generic framework for C++ reflection that can be run on any code base without any modifications of the code. The implementation of the framework was based on a two-pass compilation; the purpose of the first pass was to gather and store the class meta information. The framework was written in C++ and exploited heavily modern C++ features - variadic templates and template trait techniques.

My responsibilities in the project were to design, implement, and document the entire framework, as well as provide proof of concept implementations of the aforementioned applications.

A key part of each photorealistic rendering engine is the underlying geometry, which represents all objects in the scene. There are various types of geometry from simple meshes, NURBS, metaballs, point clouds, and dynamic geometry, to name a few. The purpose of this project was to implement various types of dynamic geometry, generating demand only when needed. Geometry handling is one of the parts of a rendering system that requires the most processing time and memory. This is why the proper choice of algorithms and thorough optimizations are fundamental.

I worked on this project and the V-Ray rendering engine. I had ownership of the dynamic geometry modules.
My responsibilities included:
- design and implementation of new dynamic geometry generation algorithms
- maintenance and improvement of the existing algorithms
- in-depth profiling, performance, and memory optimization
- integration of third-party geometry libraries
- documentation

The technologies used were C++ and several profiling tools.

The project consisted of implementing a module for the potential fitting of the Tremolo-X software. The purpose of the module was to utilize various local and global optimization techniques to find a set of model parameters that minimize the discrepancies between the model values and the real data. The module was implemented in Python and was deployed on a cluster environment making use of the OpenMPI framework.