About the service
I'm a developer in Eiffel, working where correctness is not a nice add-on but the heart of the task. Most object-oriented code rests on tests and hope; I rely on Design by Contract—contract programming. Each class openly declares its commitments: preconditions that the caller must satisfy, postconditions the method guarantees, and class invariants true throughout the object's lifetime. Such a contract is an executable specification, checkable at runtime during development and forever a piece of documentation. When something breaks, the check fires exactly at the violated boundary, and the error is caught at its source rather than surfacing three layers later as corrupted state.
My engineering is built around strict static typing, void-safety, and discipline the language enforces itself: careful inheritance with renaming and selection, separation of commands and queries, uniform access so clients don't depend on storage implementation. I design clusters of classes small, cohesive, and provably composable, holding them honest via contracts as the system grows. I work fluently with EiffelStudio and its incremental compiler, apply SCOOP for concurrency without data races, and link Eiffel to C and ready-made libraries when the project needs it. Performance and reliability are partners for me: I profile real loads rather than guess.
I take on systems from scratch and rescue fragile legacy that needs to become reliable. I can introduce contracts into under-specified code gradually, harden the riskiest modules, and leave behind a set of checks and tests documenting intent for the next engineer. If you're building something that must be right—financial logic, control software, tools other teams depend on—I bring a "verify first" approach that catches defects before your users do.
— Application and library development in Eiffel from scratch
— Design by Contract: pre- and postconditions, class invariants, loop variants
— Void-safe, strictly typed architecture of classes and clusters
— Legacy hardening and gradual contract introduction
— Concurrency via SCOOP and integration with C and external libraries
— EiffelStudio configuration, builds, profiling, and test suites
My engineering is built around strict static typing, void-safety, and discipline the language enforces itself: careful inheritance with renaming and selection, separation of commands and queries, uniform access so clients don't depend on storage implementation. I design clusters of classes small, cohesive, and provably composable, holding them honest via contracts as the system grows. I work fluently with EiffelStudio and its incremental compiler, apply SCOOP for concurrency without data races, and link Eiffel to C and ready-made libraries when the project needs it. Performance and reliability are partners for me: I profile real loads rather than guess.
I take on systems from scratch and rescue fragile legacy that needs to become reliable. I can introduce contracts into under-specified code gradually, harden the riskiest modules, and leave behind a set of checks and tests documenting intent for the next engineer. If you're building something that must be right—financial logic, control software, tools other teams depend on—I bring a "verify first" approach that catches defects before your users do.
— Application and library development in Eiffel from scratch
— Design by Contract: pre- and postconditions, class invariants, loop variants
— Void-safe, strictly typed architecture of classes and clusters
— Legacy hardening and gradual contract introduction
— Concurrency via SCOOP and integration with C and external libraries
— EiffelStudio configuration, builds, profiling, and test suites
