\"(3*(x+42)\"<\/code>, how can we figure out if the expression is correctly parenthesised?<\/p>\nIn this article I want to explore a solution that doesn't look like your usual piece of Python code.\nWe'll build it up and we'll start with a list of Booleans that flag the positions of opening parentheses:<\/p>\n
>>> expression = \"(3*(x+42)\"\n>>> [c == \"(\" for c in expression]\n[True, False, False, True, False, False, False, False, False]\n>>> list(zip(expression, _))\n[\n ('(', True),\n ('3', False),\n ('*', False),\n ('(', True),\n ('x', False),\n ('+', False),\n ('4', False),\n ('2', False),\n (')', False)\n]<\/code><\/pre>\nWe can do a similar thing for closing parentheses:<\/p>\n
>>> [c == \")\" for c in expression]\n[False, False, False, False, False, False, False, False, True]\n>>> list(zip(expression, _))\n[\n ('(', False),\n ('3', False),\n ('*', False),\n ('(', False),\n ('x', False),\n ('+', False),\n ('4', False),\n ('2', False),\n (')', True)\n]<\/code><\/pre>\nIf we subtract the two, we can create a list with the values 1<\/code>, 0<\/code>, and -1<\/code>, that tell you where we have opening parentheses or closing parentheses:<\/p>\n>>> closes = [c == \")\" for c in expression]\n>>> opens = [c == \"(\" for c in expression]\n>>> [o - c for o, c in zip(opens, closes)]\n[1, 0, 0, 1, 0, 0, 0, 0, -1]\n>>> list(zip(expression, _))\n[\n ('(', 1),\n ('3', 0),\n ('*', 0),\n ('(', 1),\n ('x', 0),\n ('+', 0),\n ('4', 0),\n ('2', 0),\n (')', -1)\n]<\/code><\/pre>\nNotice how we have the 1<\/code> next to the characters \"(\"<\/code>, -1<\/code> next to the characters \")\"<\/code>, and 0<\/code> next to every other character.<\/p>\nIt's also worth noting that the expression above only works because Booleans are integers and so we can write things like the following:<\/p>\n
>>> False - False\n0\n>>> True - False\n1\n>>> False - True\n-1<\/code><\/pre>\nTo make everything even more interesting, we can fuse the previous expressions into a single comprehension:<\/p>\n
>>> [(c == \"(\") - (c == \")\") for c in expression]\n[1, 0, 0, 1, 0, 0, 0, 0, -1]\n>>> list(zip(expression, _))\n[\n ('(', 1),\n ('3', 0),\n ('*', 0),\n ('(', 1),\n ('x', 0),\n ('+', 0),\n ('4', 0),\n ('2', 0),\n (')', -1)\n]<\/code><\/pre>\nWith this, we can compute the final solution with a single sum<\/code>:<\/p>\n>>> sum((c == \"(\") - (c == \")\") for c in expression)\n1<\/code><\/pre>\nIf the final result is positive, it means we have opened parentheses that haven't been closed.\nIf the final result is negative, it means we closed too many parentheses.\nIf the final result is exactly 0<\/code>, it means the parentheses are balanced.<\/p>\nHere are more examples:<\/p>\n
>>> sum((c == \"(\") - (c == \")\") for c in \"(3 + 6)\")\n0\n>>> sum((c == \"(\") - (c == \")\") for c in \"(3 + 6)))\")\n-2\n>>> sum((c == \"(\") - (c == \")\") for c in \"(((3...<\/code><\/pre>","summary":"Explore unusual Python features to solve the problem of determining whether an expression is properly parenthesised.","date_modified":"2025-07-23T16:49:02+02:00","tags":["algorithms","apl","programming","python"],"image":"\/user\/pages\/02.blog\/hold-my-parentheses\/thumbnail.webp"},{"title":"What learning APL taught me about Python","date_published":"2023-08-15T00:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/what-learning-apl-taught-me-about-python","url":"https:\/\/mathspp.com\/blog\/what-learning-apl-taught-me-about-python","content_html":"Learning programming in APL taught me many new things about Python and this article is an account of that.<\/p>\n\n
What learning APL taught me about Python<\/a><\/h2>\nIn the past, I've written an article where I share some areas in which my Python programming was heavily influenced by learning APL.\nYou can read this article here: “Why APL is a language worth knowing”<\/a>.<\/p>\nI've given it further thought and now I have a better understanding of how APL influenced my Python code.\nIt is likely that I am not fully aware of all the repercussions that APL had on me, but I have new things to tell you about and that is what I want to focus on in this article.<\/p>\n
So, without further ado, let me tell you what APL taught me about Python.<\/p>\n
The LOC that changed everything<\/a><\/h2>\nThere is one line of code (LOC) that changed everything!\nFiguratively speaking.<\/p>\n
Some time ago I wrote a piece of Python code pretty naturally.\nYou know when you are so focused on what you are doing that things just flow?\nThat's the state I was in.\nWhen suddenly?\nI looked at the code I had written and I saw this piece of code:<\/p>\n
sum(age > 17 for age in ages)<\/code><\/pre>\nWhen I looked at it, I was surprised by it.\nI was surprised because that is not the type of Python code that I usually see written in the books or tutorials I learn from.\nAnd it's also not a pattern I had seen in Python code from other projects...\nUntil it hit me: I wrote this Python code because of the influence that APL had on the way I think about programming.<\/p>\n
But first, let us make sure we understand this code!\nWhat does sum(age > 17 for age in ages)<\/code> do?\nWell, if ages<\/code> is a list with the age of a bunch of different people, then the line of code we saw above will count how many people are aged 18 or older:<\/p>\n>>> ages = [18, 15, 42, 73, 5, 6]\n>>> sum(age > 17 for age in ages)\n3<\/code><\/pre>\nThat's what the code does.\nThat's it.\nIt is not that magical.\nBut, curiously enough, it encapsulates plenty of things that APL taught me about Python, so let me tell you all about them.<\/p>\n
Stating the obvious<\/a><\/h2>\nNow, the remainder of this article might seem like I will be stating the obvious over and over and over and over.\nThat may be the case.\nBut the truth of the matter is, before I stated these things to myself, they hadn't clicked.\nOr, put another way, it was when I stated these things out loud and wrote about them that everything finally made sense.\nAfter all, just because something is obvious, it doesn't mean it is worthless saying it out loud!<\/p>\n
A prime example of something obvious that we can benefit from by saying it out loud – and even giving it a name – is the...<\/p>","summary":"Learning programming in APL taught me many new things about Python and this article is an account of that.","date_modified":"2025-07-23T16:49:02+02:00","tags":["apl","programming","python"],"image":"\/user\/pages\/02.blog\/what-learning-apl-taught-me-about-python\/thumbnail.webp"},{"title":"Connecting Python and Dyalog APL with sockets","date_published":"2023-01-21T00:00:00+01:00","id":"https:\/\/mathspp.com\/blog\/connecting-python-and-dyalog-apl-with-sockets","url":"https:\/\/mathspp.com\/blog\/connecting-python-and-dyalog-apl-with-sockets","content_html":"
This article shows how to communicate between Python and Dyalog APL through the use of sockets. We will use the module socket<\/code> from Python and the Conga workspace from Dyalog.<\/p>\n\n![\"\"](\"\/images\/c\/7\/9\/3\/2\/c793259a18fd94998098f3c57fd8b3b1abf2b7ad-thumbnail.webp\")
<\/p>\n
Introduction<\/a><\/h2>\nPrograms communicate with each other all the time.\nFor example, your browser communicated with my server to retrieve this article.\nSometimes, you may want your programs to communicate with others, and when that time comes, you may want to use sockets1<\/a><\/sup>.<\/p>\nThis article will show how to communicate between Python and Dyalog APL<\/a> using sockets:<\/p>\n- we will use the module
sockets<\/code> on the Python side; and<\/li>\n- we will use Conga on the Dyalog APL side.<\/li>\n<\/ul>
Both sockets<\/code> for Python and Conga for Dyalog APL come with their respective systems by default, so that should make things easier for us.<\/p>\nHow to create a socket server in Python<\/a><\/h2>\nThanks to some investigation I did some months ago and an article I wrote about sockets<\/code><\/a>, we can see that it doesn't take much code to create a socket server in Python.<\/p>\nIn fact, the four lines of code that follow are enough to create a socket server in Python that will listen on port 7342 on the local host:<\/p>\n
import socket\nserver = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\nserver.bind((\"localhost\", 7342))\nserver.listen()<\/code><\/pre>\nIf you are following along, what I suggest is that you run this code in your REPL, so that the Dyalog APL socket you create in the next step connects to your server and you see what is going on.<\/p>\n
Go ahead, paste those four lines of code in your REPL, and then add this fifth one to wait for a socket to connect:<\/p>\n
client, address = server.accept()<\/code><\/pre>\nIf all went well, running that line of code should make your interpreter hang, which is normal because you are waiting for a socket to connect to your server.<\/p>\n
Let's see how to connect from the APL side<\/p>\n
How to create a client socket in Dyalog APL<\/a><\/h2>\nTo work with sockets in Dyalog APL we need to load the Conga workspace, or we can just copy the namespace DRC<\/code> in:<\/p>\n )copy conga DRC<\/code><\/pre>\nNext up, we initialise the namespace:<\/p>\n
DRC.Init ''\n┌─┬─────────────────────────────┐\n│0│Conga loaded from: conga34_64│\n└─┴─────────────────────────────┘<\/code><\/pre>\nThe exact numbers you get in the conga34_64<\/code> portion of the output will differ from version to version (and possibly from OS to OS).<\/p>\nFinally, we use the function DRC.Clt<\/code> to create a client socket.\nWe will pass four arguments to DRC.Clt<\/code>:<\/p>\n- the name of the socket we are going to create (any character vector will do);<\/li>\n
- the address or name of the host (
'localhost'<\/code> in our example);<\/li>\n- the port to which to connect to (
7342<\/code> in our example); and<\/li>\n- the type of the socket (
'Text'<\/code> in our example):<\/li>\n<\/ul> DRC.Clt 'my socket' 'localhost' 7342 'Text'\n┌─┬─────────┐\n│0│my socket│\n└─┴─────────┘<\/code><\/pre>\nIf the first element of the result vector is a 0<\/code>, that means everything worked out and you managed to create your socket.\nOtherwise, that integer will have an error code...<\/p>","summary":"This article shows how to communicate between Python and Dyalog APL through the use of sockets. We will use the module `socket` from Python and the Conga workspace from Dyalog.","date_modified":"2025-07-23T16:49:02+02:00","tags":["apl","networking","python"],"image":"\/user\/pages\/02.blog\/connecting-python-and-dyalog-apl-with-sockets\/thumbnail.webp"},{"title":"Solving Wordle with APL","date_published":"2022-03-28T15:00:00+02:00","id":"https:\/\/mathspp.com\/blog\/solving-wordle-with-apl","url":"https:\/\/mathspp.com\/blog\/solving-wordle-with-apl","content_html":"Join me in solving the word game Wordle in (Dyalog) APL.<\/p>\n\n![\"\"](\"\/images\/2\/f\/1\/8\/4\/2f1843fc9239532c53c2d0d2ca0b46632768f425-thumbnail.webp\" "\\"A")
A screenshot of a session of Wordle I played.<\/figcaption><\/figure>Introduction<\/a><\/h2>\nWordle<\/a> is a conceptually simple game that you can play online.\n(For those of you who know it, it's like Mastermind<\/a> (the board game),\nbut with words.)\nThere is a secret word that you have to guess and you are given 6 tries\nto find out what word is the secret word.\nWhen you make a guess, you get some information back:<\/p>\n- you are told which letters of the guess match letters of the secret word;<\/li>\n
- you are told which letters of the guess exist in the secret word,\nbut are in the wrong position in the guess; and<\/li>\n
- you are told which letters of the guess don't exist in the secret word.<\/li>\n<\/ul>
For example, assume that the secret word is “chess”, and you guess “caves”:<\/p>\n
- the “c” and the “s” are in their correct positions when compared to the secret word;<\/li>\n
- the letter “e” in “caves” exists in the secret word but it's in the wrong position; and<\/li>\n
- the letters “a” and “v” do not exist in the secret word.<\/li>\n<\/ul>
Here is how the game would represent this information:<\/p>\n![\"The](\"\/user\/pages\/02.blog\/solving-wordle-with-apl\/_caves.webp\" "\\"The")
The visual representation of the letter information.<\/figcaption><\/figure>Again, recall that:<\/p>\n
- the green squares around “c” and “s” tell you that those letters are in the correct place;<\/li>\n
- the yellow square around “e” tells you that “e” exists in the secret word but in some other position; and<\/li>\n
- the gray squares around “a” and “v” tell you that “a” and “v” are not in the secret word.<\/li>\n<\/ul>
Objective<\/a><\/h2>\nWhat we want to do is write an APL<\/a> program that helps us play Wordle.\n(I have written a similar article<\/a> in the past, but using Python.)<\/p>\nWe will write a couple of functions:<\/p>\n
- a function
Score<\/code> that scores a given guess with respect to a given secret word; and<\/li>\n- a function
Filter<\/code> that returns the possible secret words with respect to a given guess and its score.<\/li>\n<\/ul>\nAll the code is available in this GitHub repository<\/a>.<\/p>\n<\/div>\nAs for the letter information, which I'll call the score of a guess, we will encode it in this way:<\/p>\n
- a
0<\/code> means the letter isn't in the secret word;<\/li>\n- a
1<\/code> means the letter is in the incorrect position; and<\/li>\n- a
2<\/code> means the letter is in the correct position.<\/li>\n<\/ul>Here are a couple of examples:<\/p>\n
![\"A](\"\/user\/pages\/02.blog\/why-apl-is-a-language-worth-knowing\/thumbnail.webp\" "\\"“A")
![\"Paint](\"\/user\/pages\/02.blog\/04.til\/034.multi-channel-transposed-convolution\/thumbnail.webp\" "\\"Diagram")
![\"Paint](\"\/user\/pages\/02.blog\/04.til\/033.transposed-convolution\/thumbnail.webp\" "\\"Representation")
![\"Paint](\"\/user\/pages\/02.blog\/04.til\/033.transposed-convolution\/_transposed.webp\" "\\"Each")
![\"\"](\"\/images\/3\/5\/b\/c\/e\/35bcec4646bc80054d47a77cfc1d0a69b5377379-thumbnail.png\" "\\"Photo")
![\"An](\"\/images\/5\/d\/5\/b\/3\/5d5b3ed7dceadb06d9253de0dbee99d3cc69abb5-thumbnail.webp\")
<\/p>\n