Hi there, I'm Blake Anderson
This blog documents things I've learned about software development and programming languages, largely
through my work on Rhovas. Resources on language design are rare,
so I hope documenting my thoughts on software and specific decisions I've made with Rhovas will help
other developers as well.
If you're interested in discussing anything in this blog, feel free to email me (WillBAnders@gmail.com
)
or tag me in the #blog
channel of my Discord server.
July 11, 2023
~10m read time
July 11, 2023
~10m read time
Today marks the 5th anniversary of Rhovas! Five years ago, I outlined the first steps for what I
wanted to create with a new programming language. Rhovas has come quite far from those original
notes, so I thought it'd be a good idea to reflect a bit on the past five years and see how things
have gone.
Additionally, to commemorate the day Rhovas now has an initial v0.0.1
release! This is largely to know what's active on the online editor, but over time this will
approach a full v1
release and come with more compatibility
guarantees. You can review the Release Notes
for a changelog and details on our versioning approach.
Finally, in combination with this release I've updated contributing guidelines to show issues (and
PRs) are now accepted. I'm comfortable with the current direction of the language/compiler where
contributions are manageable, and the language is stable enough where building programs and
identifying bugs is highly valuable. If you're interested in helping, see FAQ: How can I help?.
Continue reading...
March 28, 2023
1h30m watch time
March 28, 2023
1h30m watch time
This week I gave an introductory talk on Rhovas for the Society of
Software Developers (SSD) at the University of Florida. Rhovas is a new programming language I've
been working on focused on API design and enforcement for library development. This presentation
covers the motivation/philosophy of Rhovas as well as a handful of examples for notable language
features (subject to change).
Watch on my blog...
| Watch on YouTube...
March 25, 2023
30m watch time
March 25, 2023
30m watch time
This weekend I gave a talk at GNV BarCamp, an ad-hoc 'unconference' where attendees propose
presentation topics at the event, on software testing. Consequently, it's not that's polished but is a
fair overview on software testing covering unit/integration tests, Test Driven Development (TDD) and
Design by Contract, mocking, and multiple case studies from personal experience.
Watch on my blog...
| Watch on YouTube...
June 25, 2022
~11m read time
June 25, 2022
~11m read time
In my last post, I introduced the idea of syntax macros
for parsing embedded domain-specific languages (DSLs) like regex, SQL, and HTML. DSLs are an
excellent tool for modeling many types of specialized problems, and improving language-level support
for them is something I'm hoping to achieve in my own programming language
Rhovas.
This time, I'm going to address the harder challenge of semantic analysis - variables/function
resolution, macro hygiene,
type checking, and so on. This process has two goals: transform the current AST of the
DSL into a representation that is compatible with the host language, and perform any additional
compile-time validation that would otherwise be lost during the transformation.
For example, the code belows shows an SQL DSL being transformed into a PreparedStatement
.
This process can also validate the interpolated name
variable,
both with the variable being defined and whether it has the appropriate type (presuming the database
schema is available).
db.execute(#sql {
SELECT * FROM users
WHERE name = ${name}
});
This article is a more approachable summary of my Master's Thesis that highlights key ideas and
elaborates on points that presumed a background in programming languages. The full thesis is
available through the UF Library Catalog, and I
believe it's pretty straightforward as far as academic papers go.
Continue reading...
July 11, 2021
~9m read time
July 11, 2021
~9m read time
Domain-specific languages (DSLs) are everywhere; you just might not
recognize it. Regex is a DSL, as is SQL and HTML. C# has LINQ
for queries. Even React HTML templates are actually from a DSL called JSX.
DSLs are excellent at what they do - picking the ideal language is like picking the right tool
from the toolbox; not every problem needs the Python hammer. That said, there is little support
for DSLs within existing languages, and we often end up throwing them into string literals
hoping for the best at runtime.
Instead, I'd like to introduce a new model for implementing embedded DSLs called syntax
macros, which allow extending the syntax of the language to support the DSL. This results
in syntax like the following, where the DSL actually looks like it's own language:
db.execute(#sql {
SELECT * FROM users
WHERE name = ${name}
});
This article is a more approachable summary of my honors thesis that highlights
key ideas and elaborates on points that presumed a background in programming
languages. The full thesis is available through the UF Library Catalog,
and I believe it's pretty straightforward as far as academic papers go.
Continue reading...
November 15, 2020
~12m read time
November 15, 2020
~12m read time
Properties are a really nice feature of modern languages, and I've recently
gotten attached to them in Kotlin. For a while
I wasn't comfortable with the idea of 'fields' performing arbitrary computation,
but having used them for a few months now I'm really enjoying the simplicity -
especially when moving back to Java!
Having given it some thought, I wanted to lay out a case in support of
properties which highlights their benefits over directly accessing fields (which
is mostly about getters/setters, but nonetheless), and how we can establish some
guidelines on when properties should not be used to avoid the issue of
arbitrary computation causing side effects or other unexpected behavior.
Continue reading...