akdas

I use Vim with Dvorak. No remapping required. The keys are just in different places than on Qwerty.

Know you're talking about. That alone will make the talk more natural, as you'll be able to adapt to your audience due to having knowledge outside of just your research.

This was the biggest change between the presentations I had to give in high school and the ones in college and above. In high school, the topic was usually given to us, whereas in college and later, I got to choose the topic I was most knowledgeable about. The latter meant I was more passionate, more able to answer audience questions and more able to tailor the delivery to the audience.

One piece of advice I heard was that if you absolutely have to talk about a topic you're not familiar with, talk about being a beginner in that topic. Talk about your perspective as an outsider learning that topic in the first place.

Java streams are great. Having to go from collections to streams (`.stream()`) and back (`.collect(...)`) is annoying, but understandable from a compositional point of view.

For fun, you can further reduce the size of the code above (and IMO, make it clearer), but using `Arrays.stream(product)` and a method reference for the `map`:

    List<ProductDisplayInfo> list = Arrays
        .stream(products)
        .filter(p -> p.getCategory() == 2 || p.getCategory() == 5 && isProductUnderDiscount(p))
        .map(ProductDisplayInfo::new)
        .collect(Collectors.toList());

I work on Primitive, a novel way of visualizing and interacting with code in VR: https://primitive.io/

Half of the technical work is built around compiler technology (and more generally the implementation of programming languages, such as the various runtimes). It's been fascinating to understand how widely-used programming languages are implemented, which I talked about in a blog post about inner classes in Java (https://blog.primitive.io/inner-classes-in-java-1804ed51b7de). Similarly, it's been great to look at large open-source codebases and try to understand them. For example, we dug around the internals of IntelliJ IDEA (https://blog.primitive.io/how-intellij-idea-knows-your-code-...).

It's true that we often use compiler APIs that are already available, but we still have to understand how those compilers work, and what language features we have to support in our data extractions. Right now, we're a small, scrappy team, but in the future, we'll surely have to build out more infrastructural technology ourselves.

The other half of the technical work is working with 3D graphics and in data visualization, another area of CS I really enjoy. Making code _accessible_ at a glance is always challenging, but when I get to use that visualization to understand new code, all the hard work is worth it.

Combining all this with the non-technical work a startup entails (business development, UX, etc.) means I get to really flex my mental muscles!

You're absolutely right. Normally, the surroundings provide a form of area lighting that my image doesn't have.

I use the Phong reflection model (https://en.wikipedia.org/wiki/Phong_reflection_model), which gives materials a distinct plasticky look. Peter's materials are either purely diffuse, purely reflective or glass-like (the third one is something I didn't cover in the course at all).

Peter also uses area lighting derived from the surroundings, whereas my implementation uses point lights that result in sharp specular highlights. There are no surroundings in my image, only the lights.

No doubt Peter's materials look great. I wish I had time to cover more in my course, but I wanted to make sure I covered the prerequisite vector math as well for students without strong mathematical backgrounds.

Related to the ray tracing materials, I taught a two-day crash course on writing a ray tracer. The materials are available online: https://avik-das.github.io/build-your-own-raytracer/