#proglang — Public Fediverse posts

*Local loop control variables*

One of the criteria by which we can evaluate the design of a programming language is whether each loop control variable may, or even must, be a local variable in its loop construct.
(That means the declaration of the variable is a part of the loop construct and its scope is the construct.)

It took several decades of evolution for programming language designers to realize the usefulness of such a feature.
Old languages provide nothing of the kind.
With many newer languages it is only optional.

Different languages put different amounts of pressure on programmers to use local loop control variables.
In particular, when looking at some programming language:
Is there a standard loop construct where the loop control variable may be non-local?
If not, can programmers implement their own loop constructs where the loop control variables are non-local?

#ComputerProgramming
#ProgLang
#ProgrammingLanguageDesign
#ProgrammingLanguages

There are trade-offs in the design of every programming language, different for the different languages.
A major part of the Art of Software Engineering is choosing a language with such trade-offs that are favorable for the task at hand.
A little like the Portuguese mariners of old who hugged the African coast on their way to the Cape of Good Hope, but sailed in the western Atlantic Ocean homeward bound.

#ComputerProgramming
#ProgLang
#ProgrammingLanguages
#SoftwareEngineering

Yes, if we set about to compare Wirth's own work as a whole to Ada, it would be fair to choose Modula-2.
That would be a separate conversation: needless to say, the latter is very different from Pascal, which my earlier post was specifically focussed on.

@tfb @amoroso

#ProgLang

Great article about the loss of diversity induced by recommender systems (including LLMs):

Temperature Zero for Culture: Why Everything Is Starting to Look the Same

"A world that keeps removing the unlikely also removes the things that could have become the next likely. Ecologists have known this for a long time already and even priced it: they call it the insurance value of biodiversity, the standing reserve of rare species that cost energy and contribute nothing, until the climate shifts and one of them turns out to be what survives. A monoculture is efficient right up until the weather changes."

https://laurenleek.substack.com/p/temperature-zero-for-culture-why

Related: In my 2013 EYEO talk I used the Tower Of Babel as metaphor to talk about polyglot, diverse culture as key long-term survival strength (not punishment!) and to address the growing lack of diversity and rise of monocultures in creative coding fields, back then largely caused by centralization effects of popular frameworks (e.g. Processing, OpenFrameworks) and their social attractor effects restricting the practice and surrounding educational efforts to mostly a single family of (C-based) programming languages whilst completely disregarding other approaches, techniques and influences.

My main argument was (and still is) that diversity of languages and programming approaches (functional, imperative, object-oriented, logic, declarative...) is an important factor for long-term cultural survival and robustness, something I've also been warning about being increasingly under threat by LLM-based coding. The latter is accelerating the monopolization of existing tools/frameworks, due to their over-representation in training sets and therefore offering more "stable", usable LLM solutions, leading to diversity collapse and making it increasingly hard for new contenders to establish themselves. Also wrote more about that previously...

#Average #Diversity #Robustness #Survival #Culture #ProgLang #LLM

So they have.
I asked about Ada to understand the outlines of the Pascal family in this context (the other languages mentioned are indisputable members).
To improvise an aviation analogy, Pascal was designed, at least to a significant degree, as a trainer language and Ada was designed as an industrial language, a little like trainer airplanes and large transport (or military) aircraft.
As is well-known, Pascal's capabilities exceed what is needed for a purely trainer language, a little like Soviet designer Polikarpov's U-2, later renamed as Po-2, could be used for more than training student pilots (it was even used as a light night-time bomber during the Second World War).

@tfb @amoroso

#ProgLang

Excellent question.

On reflection, my second favorite is the language of bash.
It is big trouble in general, but when it fits, it fits very well.

Out of curiosity, does the Pascal family include Ada?

@amoroso

#ProgLang

What is your second favorite programming language? Mine is the Pascal family for its readability and expressiveness.

#ProgLang

I love the tower of Babel on the cover of the 1969 book Programming Languages: History and Fundamentals by Jean Sammet. This reference work covers the history, basics, similarities and differences of about 120 languages. Of course, there are many I never heard of.

At 820+ pages it's a hefty time capsule of early language research.

https://openlibrary.org/works/OL7269394W/Programming_Languages?edition=key%3A/books/OL58667994M

#retrocomputing #book #ProgLang

What was remarkable of the computer market of the 1980s was not only the diversity of machines and hardware solutions, but also the diversity of programming languages in general use.

#ProgLang #retrocomputing

Nikita Lisitsa posted his experience with designing and implementing his own programming language, a game scripting language that's "[...] a weird blend of C++, Rust, Python, Zig, and maybe a few other languages".

https://lisyarus.github.io/blog/posts/making-your-own-programming-language.html

#ProgLang

I've added some light "automated proving" capbilities to my geometric predicate generator.

(Context is still high performance mesh booleans, but this is applicable to so much more geometric computation)

With enough symbolic perturbation I was able to prove that the perturbed query point cannot lie on the plane.

This is not done via proof search but via rewriting / optimization.

Basically, "prove <expr>" is definitely true if we can simply "<expr>" to "true".

#geometry #proof #proglang

Currently on a side quest to dig deeper into error handling in parsers. Any parser whose diagnostic messages impress you especially (and why)?

#CS #compsci #ProgrammingLanguages #ProgLang #programming

Just submitted my latest Swedish Science Council grant proposal: "Navigating the Incomparable"!

We want to build correct-by-construction software for multi-objective optimization—helping safely navigate complex trade-offs like economic costs vs. global temperature rise (see the attached idealised Pareto front).

To do this, we're proposing three connected work packages (see diagram) moving from formal specification, to state-space reduction, and finally scalable execution. We aim to combine #FunctionalProgramming, #DependentTypes, and dimensional analysis to build algebraically accountable tools for climate policy and fusion energy.

If funded, this opens a new PhD position in 2027!

📖 Read the full abstract: https://patrikja.owlstown.net/posts/5441

#Haskell #Agda #TypeTheory #ClimateScience #FusionEnergy #ProgLang

Question for #PL folks:

Is there any usable work taking the typed assembly languages work and layering it on top of #LLVM ? Been quite a while since I read that work, but from what I remember, TAL two had the intersection / union types you'd need for SSA form.

Reason: I will (eventually) need a low-overhead, direct-to-native, and safe way to distribute executable code in a distributed system.

#CS #compsci #ProgrammingLanguages #ProgLang

Yorick Phoenix comments on the programming languages he used or was exposed to over his long career in computing. Lots of interesting anecdotes and historical tidbits.

This series of over 30 posts has no table of contents but the posts are arranged in a doubly linked list.

https://blog.scribblings.com/progaming-languages-1-cesil

#ProgLang #retrocomputing

https://www.kindness.city/blog/2026-03-22-care.html

A bit of a ranty blog today.

I really want to write software that's actually good.

Increasingly, I believe the trick to doing this isn't #types, or #proglang , or formal methods, or #agile, or #XP, or #TDD, or any other fancy technique, process, or technology. It's Care.

And the reason most software still sucks? It's not stupidity, and it's not because everyone else has been duped by the "wrong" development ideology (waterfall, formal methods, agile, etc). It's the Market.

Here's what #openbsd , #slackware, and #emacs are teaching me about taking the time to work on what matters.

Rupert Lane reconstructed the code of Joseph Weizenbaum's Online Programming Language (OPL).

Based on a printout of source code found among Weizenbaum's papers archived by MIT Libraries, I have reconstructed the language so it can live again for the first time in nearly sixty years on a IBM 7094 emulator running CTSS.

https://timereshared.com/reconstructing-joseph-weizenbaums-opl

#eliza #ProgLang #retrocomputing

This draft paper dated 1979, apparently never published, gave an historical overview of early programming languages for AI.

The document helps make sense of names like POPLER and QLISP. What's interesting is high level languages such as PLANNER and CONNIVER saw initial interest but little actual use.

https://stacks.stanford.edu/file/druid:vg077ps3762/vg077ps3762.pdf

#retrocomputing #ai #lisp #interlisp #ProgLang

X-mas comes early this year: the ICFP 2025 talks are now on YouTube.

You can catch my talk on "Domain-specific tensor languages" below. We explore implementing tensor calculus in #Haskell, supporting both Einstein notation and Penrose diagrams to model things like General Relativity and black holes. 🕳️🚀

My talk: https://www.youtube.com/watch?v=04cxfddDwuI

Full Playlists:
🔗 ICFP papers: https://www.youtube.com/watch?v=COD4tnVtHoQ&list=PLyrlk8Xaylp4WyLpPH40RBw-kZSdkpkVs
🔗 JFP First papers: https://www.youtube.com/watch?v=oZLSDFfpHp0&list=PLyrlk8Xaylp68qJ-kEeXEPne0ePPwNGFi

https://mastodon.acm.org/@sigplanav/115667300324636252

cc @sigplanav (https://sigplan.org)

#icfpsplash25 #ProgLang #TensorCalculus #Physics #FunctionalProgramming

How long have you been using Lisp? Any dialect, including Emacs Lisp.

#interlisp #lisp #ProgLang

Multi-language IDEs that interact with interpreters via protocols are now common, from classic Emacs with its inferior process protocols to VS Code with LSP and similar modern environments.

This paper described an early exploration of these ideas: a language-independend, Interlisp-based environment that interfaced with language processors over the ARPANET. In 1974.

https://dl.acm.org/doi/10.1145/1500175.1500251

#interlisp #retrocomputing #ProgLang #IDE

How would you do this? Using the Guppy programming language you can write programs with arbitrary control flow, function calls, classical logic and data types, dynamically allocated quantum and classical data, etc etc.

Since quantum computer time is very expensive, we also have a strong type (linear) system to catch many common errors at compile time.

It's open source. There is also a simulator called Selene you can use to run it. Check it out.

https://guppylang.org

#quantum #quantumcomputing #programming #proglang #guppy

Rachit Nigam on why design new programming languages and what is a language.

[...] we create programming languages to experience new ideas; ideas that would have remained inaccessible had we stayed with the old languages.

https://people.csail.mit.edu/rachit/post/why-study-programming-languages

#ProgLang #programming

#PSA Since I've just been asked again if I could use more topic-specific accounts and not mix my photography with other topics — Unfortunately, nope! I'm on a single user managed instance and cannot create new accounts on this server nor do I want to create an account for every single topic I'm interested in or posting about. However, you can filter my posts by hashtags, which I'm trying to use consistently (also for my own purposes)...

Hashtags can be browsed individually, subscribed to (via Mastodon) or even syndicated via RSS, e.g.

Browse:
http://mastodon.thi.ng/@toxi/tagged/LandscapePhotography

RSS:
http://mastodon.thi.ng/@toxi/tagged/LandscapePhotography.rss

My most commonly used tags are:

Photography:
#LandscapePhotography #NaturePhotography #NoirCountry (my B&W photos) #POV #Hiking

Open source projects:
#ThingUmbrella #ZigThing #GenArtAPI #TypeScript #Ziglang #WASM #WebAssembly #Forth #OpenSource #ProgLang

Art:
#Art #GenerativeArt #AlgorithmicArt #ProceduralArt #KineticArt #Exhibition

Music:
#Music4Coding

AI relatated:
#AI #LLM

Education/research:
#Edu #Research

Hope that helps!

#quantinuum hat on. We just announced Guppy, our #programming language for our new #quantum computer, Helios. The hardware will be publicly launched later this year, but you can get Guppy now.

Guppy is for writing programs that run in the QPU. Unlike all other quantum computers, Helios is actually a computer. Correspondingly, Guppy offers arbitrary control and (mildly restricted) classical data structures. Guppy is strongly statically typed, and quantum data is treated linearly, so you can neither leak nor double-free qubits.

Guppy is embedded in python, but is separately compiled, and maintains a clear distinction between compile-time (inside the python interpreter) and runtime (inside the QPU). You can use python for meta-programming (e.g. loop over all the qubits at compile time to build a static circuit, or have that same loop happen at runtime.). The two levels play nice together.

There is also a simulator specially made to run these programs, called Selene.

We spent a long time working on this, and I'm very proud to have it out there "for real".

Try it : `pip install guppylang`

https://guppylang.org
https://www.quantinuum.com/blog/built-for-all-introducing-our-new-software-stack
https://github.com/CQCL/guppylang

#quantumcomputing #proglang #quantum #guppylang #opensource

Dave Gauer on why small programs and programming languages are appealing. Some great thoughts, no pun intended.

https://ratfactor.com/cards/pl-small

#programming #ProgLang

If your programming language doesn't give you type safety via inference, get help... I still have mild PTSD from refactoring (and breaking) large code bases in subtle ways. With type safe/type inference, you make fundamental change to a core type and the editor walks you through everything you need to do. I'm using #fsharp but really recommending this #proglang pattern over say #ducktype where you find out the mistake at the most expensive point in the coding cycle.

Job ad 🧵 2/2
Quantinuum are looking for software engineer to help design and implement quantum programming languages. You need to have OPINIONS about types. Full-time, permanent, based in Cambridge in England.
#jobad #quantum #quantumcomputing #pl #proglang #guppylang #types

https://jobs.eu.lever.co/quantinuum/6acbcf43-a765-4f1c-a063-6849a72e612b