Specializing on Programming Languages (PL) under the supervision of Sam Tobin-Hochstadt, minoring in Logic at the Department of Philosophy.

I'm working on fast run-times of dynamically typed languages, particularly Racket. When I started, I was initially trying to figure out the effects of using Racket byte-code compiler as a front-end for Pycket, i.e. investigating the individual effects of various optimizations happening in the Racket compiler to the Pycket run-time, such as heavy inlining and/or lambda lifting.

While we were working on that, Racket decided to make the language more portable, and started adopting Chez Scheme as its run-time. So I decided to join the fray and took a different direction.

At that time, we had a rudimentary Racket implementation we were working on, namely Pycket, which is a meta-tracing JIT compiler automatically generated by the RPython framework, designed to demonstrate that efficient sound gradual typing is possible. In the new direction of research, I first helped to make the Racket more portable (see Publications), and helped it to adopt the Chez Scheme fully. And then mimicking Racket's self-hosting on Racket-on-Chez, I turned the Pycket into a full implementation of Racket, thereby having a meta-tracing JIT as a run-time for Racket.

PyPy project has shown that fast prototyping of efficient run-times for dynamic languages is possible through meta-interpretation (tracing not the user program, but the interpreter that runs it). The aim of my research is to take the meta level one step further, and show that with this setup, fast prototyping efficient run-times for self-hosting dynamic languages is also achievable.

Currently, Pycket is able to run just as fast as before on the benchmarks in previous studies. However, self-hosting comes with a big problem for tracing JITs; giant dispatch-loops. This is essentially the same problem that Mozilla has faced quite a while ago with TraceMonkey, which is basically that you lose more when slow than you gain when fast. My work suggests some workarounds for this problem and tries to show that an efficient run-time with a meta-tracing JIT is still achievable for fast prototyping self-hosting dynamic languages.

This was the continuation of my masters on natural language processing and machine learning. After researching for another year on the system I built, I decided to pursue a PhD on programming languages instead.

I was part of the Text Analytics and Bio-Informatics Lab. Studied the theory of computation, automated theorem proving, then focused on machine learning and natural language processing. Worked on closed domain question answering systems for Turkish high-school students. (government funded project)

Got both theoretical and practical experience. Programmed in both imperative, functional, logic languages. Concentrated on the theory of computation, and programming languages, design and implementation.

Juju is an orchestration and modeling tool for deployment of complex cloud workloads. It manages the life-cycle of the charmed operators for Kubernetes and traditional Linux apps, with declarative relations between operators for automated microservice integration. It also facilitates day 2 operations, such as scaling, upgrading and monitoring. I work in the core dev team (of 15). I'm involved in maintaining the main clients (e.g., cli, python-libjuju) and the facade API, charmhub integration, worked on data schema for moving from MongoDB to dqlite, and general bug fix and maintenance. Mainly in Go and Python.

Terraform Juju Provider is a terraform provider that enables integration with Juju while managing terraform environments. Started developing as part of my work on the Juju API. Implemented new features, worked on moving from using sdk2 to the new terraform provider framework, maintained release cadence of new versions. All in Go.

A meta-tracing JIT initially designed to reduce the overhead of sound gradual typing, nowadays a run-time for self-hosting full Racket. I am the main developer and maintainer. I re-implemented the front-end to make the Racket bootstrap itself on Pycket, i.e., achieved a full Racket implementation on RPython framework. Developed performance debugging tools, implemented various optimizations and large number of run-time primitives. Maintained and improved the data structure implementations (hash tables, vectors, structs etc.). For details, see my PhD description.

[https://github.com/pycket/pycket]

A full-stack nanopass compiler from a small subset of Racket all the way down to x86_64 assembly. Started for fun, collaborated with a friend to turn it into a school project, then it turned into an open source project. Built and tested all the passes (e.g. closure conversion, register allocation, code-gen, etc.).

[https://github.com/cderici/rax]

I collaborated with Jeremy Siek and Matthew Heimerdinger to help prove the correctness of a closure conversion pass of a compiler for a functional language represented as denotational semantics in Isabelle.

[https://github.com/madheime/denotsem-compiler] (might be a private repo)

A closed domain question answering system for high school students. Funded by TUBITAK (The Scientific and Technological Research Council of Turkey). I lead the research and development, 3 faculty members (both from CS and also School of Education) and 4 grad students were involved. This was my MSc thesis work, so I worked on pretty much everything about it (see Publications). I developed a hybrid model for question analyzing (Hidden Markov Model along with a rule-based model), developed a reliability score for web-pages/documents, used the Indri search engine for processing and retrieval for answer generation, implemented both the front and back-end in Python.

Did you know that it's very hard for Deaf people to read? Well I didn't. Apparently reading for Deaf people is a sort of learning a new foreign language. This is a joint work with the Department of Western Languages & Literature to build a web-based application to teach people with hearing disability how to read. Two faculties from Linguistics, one from CS, and two RAs were involved. Project aims to develop a stable framework on which the Turkish grammar lectures and exercises for Deaf people can easily be provided. I collaborated with the linguists to implement the application (available on both PC and mobile) that’s designed specifically for Deaf people. Used JavaScript, HTML and PhoneGap.

Data Collection, Processing and Visualization Framework for real-time social network data, lead by Suzan Üsküdarlı. 4 faculty members and 7 grad students were involved. I developed parts of the processing library with JavaEE, implementing certain tools used for various kinds of analyses, such as centrality analysis, stop-word collection, etc.

[http://direnaj-staging.cmpe.boun.edu.tr/] (might be private because of the Twitter privacy terms)

This is a resolution-refutation style automated theorem prover. I developed it for fun at first, then I turned it into a project for school. Written all in Racket by myself.

[https://github.com/cderici/FARS]

This was my undergraduate thesis (see BSc description). It was a project from Brown University under supervision of Shriram Krishnamurthi, a compiler from Racket Advanced Student Language to JS and HTML. I participated in the development of both compiler and run-time libraries. My major contribution was to add the tail-calls. Nowadays it is used on WeScheme by the Bootstrap curriculum.

[https://github.com/cderici/moby-scheme]