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...

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...

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...

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}
});

db.execute(PreparedStatement(
    "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...

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...

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...