Rack­et­fest—Con­fer­ence for fans of the Rack­et pro­gram­ming lan­guage

Lamb­da, the Drag­on Slay­er! [slides] [video]

Ab­stract This talk dis­cuss­es a pro­to­type work im­ple­ment­ing Rack­et on top of MLIR and LLVM. As an al­ter­na­tive im­ple­men­ta­tion to the cur­rent ex­ist­ing im­ple­men­ta­tion (the main Rack­et im­ple­men­ta­tion, Py­ck­et, etc.) with a fo­cus on speed, and pro­duc­tion use of Rack­et. We’ll dis­cuss the main chal­lenges, where we are at, where do we want to go and how you can help.

Na­tive Apps with Rack­et [slides]

Ab­stract I will be talk­ing about a method I’ve been em­ploy­ing to build na­tive ma­cOS apps by em­bed­ding Rack­et. Specif­i­cal­ly, I’ll be talk­ing about the im­ple­men­ta­tion of my lat­est app, Franz, a na­tive ma­cOS client for Apache Kaf­ka.

Build­ing a Data Man­age­ment Sys­tem the Lan­guage-Ori­ent­ed Way [slides]

Ab­stract In my re­search group at Im­pe­r­i­al Col­lege Lon­don, we are de­vel­op­ing a Data Man­age­ment Sys­tem with un­prece­dent­ed ex­ten­si­bil­i­ty as well as bare-met­al per­for­mance. Usu­al­ly, ex­ten­si­bil­i­ty and per­for­mance re­quire sac­ri­fic­ing main­tain­abil­i­ty of the code­base. In my pre­sen­ta­tion, I will out­line how a lan­guage-ori­ent­ed ap­proach al­lowed us to achieve all three: per­for­mance, ex­ten­si­bil­i­ty and main­tain­abil­i­ty. In­ter­est­ing­ly, much of the sys­tem is not im­ple­ment­ed in Rack­et but in C++. How­ev­er, both the C++ as well as the Rack­et code fol­low the lan­guage-ori­ent­ed pro­gram­ming par­a­digm.

Im­ple­ment­ing pro­to­cols and syn­tax-based al­go­rithm de­vel­op­ment [slides]

Ab­stract The read pro­ce­dure as it is pro­vid­ed by Rack­et reads an en­tire S-ex­pres­sion. But what if your in­com­ing data does not con­sist of S-ex­pres­sions? In this talk I’ll walk you through cre­at­ing your own in­put-port im­ple­ment­ing cus­tom pro­to­col. The im­ple­men­ta­tion will in­clude chang­ing the read se­man­tics. There are a few pit­falls which may seem hard to avoid, but we will deal with them as well. In the sec­ond part of the talk, I’ll dis­cuss how cus­tom syn­tax can help you de­vel­op your al­go­rithms. Es­pe­cial­ly when cre­at­ing vari­ants of vari­ants (that is not a typo) of pro­ce­dures im­ple­ment­ing cer­tain func­tion­al­i­ty with slight­ly dif­fer­ent as­sump­tions and out­comes.

Sketch­ing [slides]

Ab­stract Sketch­ing is a lan­guage that en­ables be­gin­ners, artists and kids to make pro­grams that pro­duce im­ages and an­i­ma­tions. The in­spi­ra­tion was:

What would Pro­cess­ing look like, if it were writ­ten in Rack­et?

We will see a few ex­am­ples—and take a look at the im­ple­men­ta­tion.

Long, state­ful on­line in­ter­ac­tions with con­game [slides]

Ab­stract To­geth­er with Bog­dan Popa, we de­vel­oped con­game, the self-pro­claimed best soft­ware for on­line eco­nom­ics ex­per­i­ments im­ple­ment­ed in Rack­et. In this talk, I will high­light the fea­tures of con­game that make it pos­si­ble to build and de­sign stud­ies fast—and most im­por­tant­ly, to al­low study de­sign­ers to break out, reuse, and mix and match stud­ies and sub­stud­ies to de­vel­op a tru­ly long con.

Rack­et ecosys­tem in Gen­too [slides]

Ab­stract We’ll talk about greater in­te­gra­tion of Rack­et and Gen­too Lin­ux sys­tems: Pro­jects, li­braries and tools to sup­port the Rack­et ecosys­tem as well as the Gen­too Pack­age Man­ag­er Spec­i­fi­ca­tion doc­u­ment.

A Rack­et Glos­sary [slides]

Ab­stract Learn­ing Rack­et can be tough. You’re con­front­ed with a flood of con­cepts and of­ten it’s hard to tell whether these con­cepts are some­thing ba­sic you should learn soon or some­thing rather ad­vanced that can wait un­til lat­er.

There­fore, the Rack­et glos­sary sorts con­cepts into ba­sic, in­ter­me­di­ate and ad­vanced cat­e­gories. Also, in­di­vid­ual glos­sary en­tries try to show what’s im­por­tant when start­ing with Rack­et ver­sus things you like­ly won’t need so soon. There are also some tips about how to use or not use a Rack­et fea­ture. Apart from the glos­sary con­tent, the talk de­scribes chal­lenges I ran into, the cur­rent state of the project and how you can con­tribute (if you want to :-)).

de­fine2 [slides]

Ab­stract Do you like writ­ing #:some-keyword some-keyword?

Do you like catch­ing ar­i­ty and key­word er­rors at run-time only?

Do you like to have to rewrite the de­fault val­ue for dict-ref when you make a wrap­per for it?

Do you like writ­ing wrap­pers for func­tions of many ar­gu­ments and key­words, such as plot?

If you replied yes to all of these ques­tions, define2 is not for you!

De­fine2 pro­vides a re­place­ment for define which it im­proves upon by pro­vid­ing sta­t­ic sig­na­ture checks at call sites to catch many ar­i­ty and key­word er­rors at com­pile time, short­er key­word de­f­i­n­i­tions, au­to­mat­ic pass-through of de­fault val­ues and wrap­per func­tions.

Open Mic

Ab­stract The open mic at the end of Rack­et­fest is a time for light­ning talks or oth­er short items. Sound off about what­ev­er Rack­et-y thing is on your mind. Per­fect for pre­sent­ing work-in-progress, spec­u­la­tive ideas, thoughts about Rack­et, you name it.