Revising the Latria Programming Language
Nov. 20th, 2021
I started writing the Latria programming language back in 2014, and finished it sometime in 2015.
I also originally wrote a small article about Latria in 2015.
I continued working on it until 2017, but I haven't worked on it sense.
Recently I've become motivated to revisit my old work, and to breathe new life into it.
In particular, I go over some of goals and ideals for this language, and how I can take my recent studies in programming language theory to improve Latria.
Link to the full article.
Writing a Resume in LaTeX
Nov. 5th, 2021
I've recently been applying for careers, and have found myself exploring how I could best design my resume in LaTeX.
I've had several years of experience writing technical documents in LaTeX, but none in writing a resume (or a CV for that matter).
My first versions were not quite up to par, but it was through repeated iteration and exploration that I've begun to settle on a design that I'm happy with.
Here are some points that I would like to share about writing a resume/CV in LaTeX...
Link to the full article.
Functional Domain-Specific Shader Language (FDSSL)
A coleague and myself have recently undertaken early work on a higher-level shader language that compiles to OpenGL Shading Language (GLSL).
This effort comes from my own personal experience working with GLSL shaders, and witnessing the complexity that they often entail.
To be frank I thoroughly enjoy working with shaders because of this complexity and the customization it enables, but it is difficult to get new-comers to understand how to work with and debug shaders for the same reasons.
To address this, we wanted to design a language with some simple goals:
- a simplified syntax with regard to GLSL
- a functional paradigm
- support shader composition (effectful sequencing)
- support function composition
- unify vertex and fragment shader workflows into a single script
- enforce strong typing and ensure type safety
- compile to various GLSL versions
Our initial efforts produced a workable version of FDSSL, but we still have much we would like to do.
Ultimately, we're hoping that this language provides a way for general necomers to computer graphics (or newcomers from functional languages) to be able to ease into GLSL itself.
If our efforts are effective, we would also like to see how FDSSL could work in practical applications.
Upon completion, we are also thinking about making this tool available online as a Web Assembly module.
FDSSL on Github.
My MS thesis, Structuring Teachable Knowledge through Program-Concept Classifications, was finished and defended mid-June 2021.
It was quite a difficult effort, but well worth the time and experience.
I knew when I returned to Oregon State University in January 2018 that I wanted to finish not only my undergrad, but my MS as well.
Earlier in the same year I never would have imagined that I would go back, but I am more than happy that I did.
I already had acquired practical CS engineering experience in the 5 years before, but I was ready to challenge my understanding and to learn more about computer graphics, programming languages, and education.
Having achieved an MS, it's been nice to take some time to reflect back on my work and what I have learned.
Thesis: Structuring Teachable Knowledge through Program-Concept Classifications.
While working on my thesis I researched heavily into Formal Concept Analysis (FCA), a theory that allows describing and classifiying objects and their attributes together.
The resulting classifications can be related together in a complete lattice, which has properties that enable clear paths of exploration through those classifications.
The theory itself is a tad dense, but it is sound and clear once understood.
I found it to be effective given the fact we had programs and concepts we wanted to associate to each other, which correlated nicely with FCA's notion of objects and attributes.
We wanted to be able to guide the way programs were presented based on the concepts that they entailed.
We also wanted to avoid oversimplifying with a linear order, and to instead provide a series of paths that account for the possible programs and concepts a learner already may understand.
Using FCA was a natural solution to combining programs with their attributes, and it gave us a structure that facilitated multiple paths of exploration.
Since we were interested in building classifications for the sake of guiding which programs and concepts were presented in what order, Machine Learning techniques could also have been utilized instead of FCA.
Using ML can produce classification systems that work just as well, or better, but they are often not easy to explain or customize.
While ML is not unreasonable for this application, we wanted to produce work that was customizable for a given set of programs and concepts, and could be easily understood in terms of set & lattice theory.
With FCA there are no decision boundaries or weights involved, simply a series of sub-set relations and a directly customizable set of programs and concepts, which better suited our constraints.
With that being said further work on ordering programs through ML techniques is still worthwhile exploring.
There is much more to detail as to how this program-concept classification technique was developed from FCA, and the rationale as to why.
If you're interested you can read my thesis below, and feel free to jump towards the chapters that are particularly of interest.
As one recommendation, it's helpful to first familiarize yourself with the basics of FCA, as it forms the groundwork of the classification system used in the thesis.
BoGL: The Board Game Language
While finishing up my undergrad at Oregon State University myself and a group of students were putting the finishing touches on the Board Game Language (BoGL).
BoGL, our capstone project, is a functional domain-specific programming language geared towards teaching new CS students.
Additionally, the language (as the name implies) is geared towards teaching these concepts through the lens of board games.
This project started around August 2019 and continues today, and working on it has been a wonderful experience!
Link to BoGL Online
By June 2019 we had successfully finished implementing the base language for public use.
However, the circumstances around the world had changed due to the COVID-19 pandemic.
Our original plan was to reach students by deploying BoGL to iPads via a native app.
This already added complexity, but we were also facing a situation where it was uncertain whether students would have access to any particular device to start with.
To address this, and to encompass as many devices as possible, we switched into deploying BoGL through a webapp.
We were then able to provide BoGL to students regardless of whether they had access to a computer, tablet, phone, or something else.
So long as they had a relatively recent browser on a web-capable device, they could program with BoGL.
We were (and still are) extrememly proud of this accomplishment, and I was very happy to have been a part of it.
To this day BoGL has been taught in summer camps, middle school classes, an introductory college course, and is likely to continue to expand to more venues in the future.
and Source on Github
April 22nd, 2020
A data visualization tool for observing the underlying structure of files in a data agnostic fashion.
This version is the 5th iteration of a tool that I wrote back in 2014, and has come a long way since.
I have always had an interest in visualizing problems, and in particular being able to visualize the way software is structured at rest, and while running.
The general idea of Banter was to produce a mapping of raw data so that a visual understanding could be created in an otherwise opaque system.
Specific categories of files (images, machine code, compressed data, tables, strings, etc.) can be seen and comprehended purely by visual pattern alone.
Banter on Github.
I always have fun popping open things to see how they work inside, and Banter was a way for me to perform this in a digital context.
There are numerous interesting observations I have made over the years playing around with this tool, and it has helped to give me a better understanding of machine code per architecture, compressed archives, images, and other structural aspects.
I believe I will come back to this concept later on, but apply it in a more specific context.
Research into software and program visualization has been done in the past, and has had issues with weak adoption in practical applications.
I believe there is something more to be discovered in this field, but I believe it will take more time, and a slightly different perspective.
Fractal Brownian Motion
March 30th, 2020
I was playing around with fractal brownian motion (fbm) as a form of generating computer graphics noise.
I implemented a terrain generator based off of fbm for land, water, and clouds.
The generation of the land as a heightmap from the resulting values came out quite nice, and I was able to generate fairly decent types of terrain in OpenGL Shader Language.
The approach I used allowed me to perform nearly all of the generation for the terrain in shaders, along with the water and clouds.
The water itself was also an interesting experiment, which was a simple sin wave modifed with a light dash of fbm to give it an uneven wavey texture.
The results here were quite surprising in terms of quality, and this is something I will certainly look into down the road.
The clouds themselves were implemented using fbm as well, but were generated using volumetric ray casting.
This technique allows a ray to be cast through a solid surface, computing the fbm values as the ray moves through the surface.
The result is calculated dynamically, and as the eye position changes, the resulting values computed by the rays change as well.
To the viewer it then appears that a solid surface (such as a cube) is in fact a volume of clouds.
Adding a slight adjustment with regards to time and a flowing volume of clouds was completed.
FBM Terrain Generator on Github.
Blind Search in Pacman
Mar 30th, 2020
Various search algorithms that I implemented on a simple HTML5 implementation of Pacman.
I was interested in seeing how various heuristic search techniques would compare against uninformed search approaches.
What was interesting is how quickly a breadth first search can finish a level of Pacman, even if it runs through lives rather quickly.
Even if it doesn't play as optimally as would be disired, it still plays better than most humans.
In addition, there may be some interesting follow up research with regards to how longevity and survival can factor into using search on Pacman.
Blind Search in Pacman on Github.
March 8th, 2017
While experimenting with verifying the structure of HTML (from Metatest and Sitecheck before), I went ahead and spent some time to write up a simple parser in php.
This can go through most HTML and convert it into json, which can then be worked on by other programs.
The plan was to utilize this as a step in later building and processing websites as JSON, and then decoding them back into HTML, but I decided to leave it at this.
HTJSON on Github.
Working on Parse
After Parse went open source, we had already been using their php SDK for some time at Axolsoft, and we had to figure how to handle the migration.
Over time I ended up working more on the sdk itself, contributing to it, and eventually taking it on as a project of my own.
It was definitely a lot of fun fixing bugs, introducing features, managing PRs, and bringing the test suite up to spec.
Parse PHP SDK on Github.
July 14th, 2016
A small programming language that I wrote some time ago.
Based heavily off of Lua, and a means by which to test some theories and ideas of developing a simple language.
Latria Article Link.
An old app that I wrote that was an iOS version of the online Metatest tool I had written before.
SiteCheck Article Link.
A web based tool for testing metatag integration on websites.
Verified and checked for proper integration of third party tags to enhance posting and sharing on twitter and facebook.
The primary means was a test to apply some complex regexes to attempt to parse HTML, which being inherently irregular needed some programming around it to handle some odd cases.
Inadvertently, this also turned out to be a handy approach towards verifying the structure of an HTML document.
Metatest Article Link.
After Bit Shooter I wanted to see what it would be like to create an entire application interface purely in OpenGL.
This was probably one of my favorite applications that I built, one which created a fully dynamic interface for a Hangman game.
In addition, it gave me an excuse to play around with implementing some bluetooth networking code, and it ended up working out quite well.
Creating the animation of the letter tray at the bottom was really pretty neat too.
Hangman Azul Article Link.
Started working at a new business called Axolsoft as the Head Software Engineer.
The majority of my work was programmer-centric, involving developing a set of internal tools, several online portals, and when possible automating any standardized procedures.
Link to Axolsoft.
A simple soundboard application, made up of the leftover components from developing BitShooter. Long since defunct now.
Floidia Article Link.
The first game that I ever wrote for Android in early 2013. Utilized OpenGL, and was eventually written across to iOS as well.
Bit Shooter Article Link.