Writing

As I prom­ised in A fresh leaf, I want to share my ex­per­i­ences with us­ing LLMs for agen­tic de­vel­op­ment in the last three months. Sum­mar­ised: I star­ted as an ini­tial scep­tic, be­came quite en­thu­si­astic, and am now mod­er­ately en­thu­si­astic and guarded for the fu­ture. Al­low me to take you through my jour­ney.

It has been a very long time since I pos­ted a new art­icle. The reas­ons for this are quite com­mon­place. Start­ing a fam­ily and build­ing a ca­reer cap­tured both my in­terest and en­ergy, leav­ing little of either for shar­ing.

FinagleCon was held at TwitterHQ in San Fran­cisco. It is re­fresh­ing to see a nice work­ing at­mo­sphere with free food and drinks. Now for the con­tents.

Docker’s new tools an­nounced at DockerCon ad­dress pro­vi­sion­ing, clus­ter­ing, and ap­plic­a­tion or­ches­tra­tion.

The Ad­vanced Akka course is provided by Typesafe and is aimed at teach­ing ad­vanced us­ages of Akka. The course cov­ers the ba­sics of Akka, Re­mot­ing, Clus­ter­ing, Routers, CRDTs, Cluster Shard­ing and Akka Per­sist­ance. The fol­low­ing post starts with a gen­eral in­tro­duc­tion to Akka and presents the takeaways from the course as we ex­per­i­enced them.

Deep and shal­low em­bed­ding are terms as­so­ci­ated with Do­main Spe­cific Lan­guages (DSL). A DSL is a lan­guage geared to­ward a spe­cific do­main. The dot lan­guage is an ex­ample of such a DSL for de­scrib­ing Graphs. Con­cep­tu­ally, a shal­low em­bed­ding cap­tures the se­mantics of the data of the do­main in a data type and provides a fixed in­ter­pret­a­tion of the data, whereas a deep em­bed­ding goes bey­ond this and cap­tures the se­mantics of the op­er­a­tions on the do­main en­abling vari­able in­ter­pret­a­tions.

We all want to cre­ate good look­ing doc­u­ments and good look­ing doc­u­ments need good look­ing im­ages. Be­cause we want con­sist­ency and be­cause we are lazy we want to do this as auto­matic as pos­sible. That is why we use LaTeX, it cre­ates beau­ti­fully type­set doc­u­ments without much manual ef­fort.

We are reach­ing lim­its of what is feas­ible with im­per­at­ive lan­guages and we should move to de­clar­at­ive lan­guages. When ap­plic­a­tions writ­ten in im­per­at­ive lan­guages grow, the code be­comes con­vo­luted. Why? Im­per­at­ively pro­grammed ap­plic­a­tions con­tain state­ments such as if X do Y else do Z. As Y and Z con­tain in­vis­ible side-effects the cor­rect­ness of the pro­gram re­lies on some im­pli­cit in­vari­ant. This in­vari­ant has to be main­tained by the pro­gram­mer or else the code will break. Thus each time a new fea­ture is ad­ded to an ap­plic­a­tion or a bug is fixed the code for the ap­plic­a­tion gets more com­plex as keep­ing the in­vari­ant in­tact be­comes harder. After a while the code be­comes spaghetti-code and bugs are in­tro­duced as the pro­gram­mer fails to main­tain the in­vari­ant. This is go­ing to hap­pen des­pite the best in­ten­tions of the pro­gram­mer to keep things clean. Why is this?

People tend to only un­der­stand what they can see. For most people it is dif­fi­cult to grasp more ab­stract mat­ters without some­how visu­al­ising them. Soft­ware is an ex­ample of such an ab­stract mat­ter. Let us visit the pro­cess of de­vel­op­ing soft­ware through a com­par­ison with de­vel­op­ing a build­ing.

With this script it should be pos­sible to in­stall and build the JCU app in a local dir­ect­ory. It does not build the UHC for you. If that is wanted the op­tion could be build in of course!