exquisitecorp
/
gemini-capsule
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

initial commit

This commit is contained in:
exquisitecorp 2021-01-20 03:21:57 -05:00
commit 6f260dc2d8
8 changed files with 485 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
index.gmi Normal file
View File

@ -0,0 +1,36 @@
# Lettuce gemlog
## Generative music, art, coding, learning, politics, whatever
This gemlog is best visited between 1am and 6am local time.
```
.-~~~~-.
/ ( ( ' \
| ( ) ) |
\ ) ' } / /
(` \ , / ~)
`-.`\/_.-'
jgs `""
```
# Posts
=> programming-forth.gmi 2021-01-20 - Programming FORTH
=> short-review-of-clients.gmi 2021-01-19 - A Short Review of Gemini Clients
=> lets-not-like.gmi 2021-01-08 - Let's not Like: Avoiding attention economy on Gemini
=> programming-patching.gmi 2020-12-12 - Beginner's Mind: Programming and Patching and Synthesizing
=> primitiveturing.gmi - 2020-12-02 - Building a primitive turing machine module on Monome Teletype
=> microscores.gmi - 2020-11-27 - Very short musical scores for improvisational music, solo or with others
=> musiclog.gmi 2020-11-23 - A post about putting together albums of my recent music on modular synth

18
lets-not-like.gmi Normal file
View File

@ -0,0 +1,18 @@
# Likes on Gemini? NO!
2020-01-08
This is a pretty short post/rant about the new phenomenon I've noticed of *likes* on our nascent Gemini network/protocol.
WE DON'T NEED THEM!
*Liking* seems to come from an internal place of good. But it's actually a pernicious habit that grew out of social media. Liking, favoriting, starring... These are empty gestures. While we may think we are registering a digital head nod or smile, the end result of favoriting/liking is a quest for that addictive feeling one gets from accruing more and more of these likes in a never-ending quest. Even my favorite *social media* space and beloved community on Mastodon suffers from this problem. Heck, I am a hypocrite and use likes on Mastodon! I understand the desire, but I think it's a net negative for us here. Let's not kick off such an empty and addictive vague gesture.
Let's not clog our writing spaces with these extraneous attention-seeking numbers. Let's not add to the mental and visual clutter.
As I write this in January 2021 only a few gemlogs/capsules have implemented this like feature. But I say it should probably stop. Don't do it! Put your effort elsewhere. Send comments! Via email, via forms, or whatever. That at least has the potential for the start of a continuing conversation.
But just say no to likes!
End rant.

55
microscores.gmi Normal file
View File

@ -0,0 +1,55 @@
# Micro Music Scores
Very short scores (written instructions for performance) of 280 characters or less.
These scores are inspired by:
* The guided improvisational music techniques of experimental jazz saxophonist and music teacher Tom Hall, author of Free Improvisation: A Practical Guide.
* The Micro Fiction Games Jam (and its numerous submissions), a two-week long jam that was held to write and submit small tabletop roleplaying games that are 280 characters or less (can fit in a tweet!), organized by James Chip.
A third and only slightly more distant inspiration is Yoko Ono's Grapefruit, a book of Fluxus instruction pieces.
# Instructions for creating a score
* For 1 or more players. Instrument (including voice) could be specified. Or not.
* 280 character limit.
# Suggestion of instruments for non-musicians
Everyone can make sound. Musicians make intentional choices to make sound. Beginner's mind will suit you fine here.
Expertise is not the aim. Pick any instrument that you can use to make notes aka individual units of sound. Synth software is not ideal. Being able to make responsive intuitive sounds, by hitting a button, by making sound with your mouth, by tapping a drum, pressing piano keys is great. If you use a phone app or device, be able to play individual sounds on command.
# How to End a Piece
Improvised music has natural endings. You must mutually accept them rather than rush past and keep making noise. Endings are often at moments when you would take a breath, when a section feels like the point was just made, when a silence has just happened, or when it just feels right. Accept the ending. Enjoy the feeling of ending a piece.
List of Scores
Warm-up solo
Choose a sound texture like blowing wind, sigh, hum, etc. Start small and repeat the texture, making variations and leaving space, allowing yourself to breathe between sounds. Don't worry whether it's music. Continue for 1 to 2 minutes. When it feels right, begin to fade out.
Duet
One person starts improvising a 30 sec solo, with a beginning, middle, then end with a nod, breath or gesture to bridge to the next player, who immediately begins their own 30 second section. Continue to alternate between players in 30 section chunks. Do at least 3 sets.
Call and Response
Play a short segment of just a few notes or sounds. Your partner plays back a similar sounding pattern. You repeat. Your partner repeats. As you go back and forth, allow yourself to be influenced and drift with your partner as you echo back together.
Dots and Dashes
All players make fast short (aka "staccato") notes rapidly. Gradually, together, begin slowing the speed of your notes, mirroring sounds, til a note stretches out long. One person starts and all begin gradually speeding up till eventually ending with rapid sounds again.
# Suggested Listening
Bobby McFerrin - Circle Songs - voice
Mary Halvorson and Miles Okazaki - Jazz Fest Sarajevo 2020 - guitars
White Noise Sessions - sax, drums
Hanatarash / live in La Mama - drums, barrels
=> https://www.youtube.com/user/tomhallfreeimprov Tom Hall recorded a year of videos dedicated to free improvisation (http)

31
musiclog.gmi Normal file
View File

@ -0,0 +1,31 @@
# Music Log
23-11-2020
=> https://exquisitecorp.bandcamp.com/album/catalog-of-attributes The album I recorded and am referencing below (http)
Tonight I mastered Catalog of Attributes and put it up on my Exquisite Corp Bandcamp. As in the past 5 or 6 albums I've done, all music on this album was recorded and mastered within a few days. I really like these tracks. Yesterday I went to Prospect Park and sat out in the woods, near the meandering loping lake-stream in the middle. I listened to Huerco S.'s album Those Of You Who Have Never (And Also Those Who Have). It's 4 years old now, from 2016. A great album title! To find the name I looked on Discogs and accidentally looked at the reviews. Someone described it as ambient music you can dance to and that's a great description. I wanna make that!
During the month of October I participated in Looptober. I made a track a day for the month; despite the name, they were not technically loops but instead a helpful exercise, one with a ready audience of peers. I posted my tracks to Mastodon. Rather than just record everything, I found myself adding a whole new workflow. I left my instrument plugged in so starting to make music was easy. Literally just flip the switch, put on headphones, and turn on the recording device. Second, I didn't ambiently turn on the recording device to capture everything for sifting later. I was much more intentional. When I hit into a rich vein of sound and rhythm and it felt like a track was going to come out, only at that time did I hit the record button. I also tried to pay attention to transitions: fading in and out. Lastly, despite making the music joyfully and rapidly, when listening back later I allowed myself to cut. If a track that had been fun to play and I thought at the time was strong turned out not to be the solid piece I had imagined, I cut it. In fact, learning to cut more is extremely useful. Sometimes I took notes or scribbled down possible track titles or even just a number of the track and a star or a note to cut the end sooner. These would all be useful new skills. At the end of the month I put Sloptember online, and have since recorded and released 5 more albums on Bandcamp before the one tonight. That's a lot of music!
The most obviously key technique I've taken on is daily practice. Even though I'm not participating in Looptober's one-a-day track anymore, for the month of November, I've mostly kept the practice up. Even if it's late, past my bedtime, and I'm really done, I still will turn on the modular and see what comes from the patch set up from the previous night's track, or leftover in the morphagen's pseudo tape loops. The daily practice means I don't become rusty. I have an intuitive sense of what works, how far I can push certain effects, and even which directions to turn next. I'm thankful for this feeling.
To finish the works, I take the audio off of my Zoom H-5 recorder and then bring it into Audition and use Izotope Ozone Elements mastering plugin. I add a little compression, limiting, EQ'ing. There's much room for me to improve here.
I received the book Making Music: 74 Creative Strategies for Electronic Music Producers in the mail 2 days ago and started reading, based on my friend Aaron's suggestion. It's really great. Ostensibly published by Ableton, the book is actually really solidly written with ideas that can be applied to any electronic music production: it's not specific to their software, or even software in specific. I mean, I'm mostly using hardware except at the final mastering stage. It's also so far applicable to any genre, which is really nice.
The book is broken into three main sections: Problems of Beginning, Problems of Problems of Progressing, Problems of Finishing. This makes me think of a chess book with its openings, middle game and endgame. The first section is by far the longest. I'm not someone who suffers from lack of ideas or artist's block. But the suggestions so far are really great: ways to analyze my own music; tips for breaking down others' successes, based on my own evaluation; and using this combo to develop my own techniques and workflows. I haven't even gotten very far in the book, and so far I've used several of the ideas.
Catalog of Attributes is the name of one of the creative strategies in the book, and I liked the name and activity, so it's now the name of my album using that technique. Essentially, you listen to a track or in my case an album, that you like. Many times. You write down lots of description, breaking down the techniques, specifications, all the little facets that can be used to describe the track. Here are some of the attributes I wrote down about the Huerco S. album track:
* bumbling along, loping
* lazy, hazy, slightly saturated and warm, but not overly so
* echo delay
* 2 (synth) lines that are in relation but not exactly the same. A lower base/mid that echoes off a tap that does the same. Leaving lots of space.
* not overly compressed
* no excessive knob-twisting. Very little in fact. (i.e. no acid tweak sounds) The same effets are going on for a while. The change interest happens based on space between teh little segments of notes.
* A little phasing between the two synth line segments, so even though there is the use of repetition it doesn't sound overly repetitive.
When I sat down to play music last night I guess I kept these ideas in the back of my mind. After recording, I took some notes on my own music, my own catalog of attributes: just letting it play out; drone; no excessive knob twiddling; a little saturated and hopefully warm; a little filtering; randomness is constrained so it won't go too far out of bounds but enough variation that it stays interesting and enough to listen for. Great drone and mini segments
I'm feeling pretty good about what I've made.

64
primitiveturing.gmi Normal file
View File

@ -0,0 +1,64 @@
# Primitive Turing Machines
### My Buchla background
When I was a child and wanted to learn to program I got books from the library on Logo and Forth. I never got to actually program in those languages as a kid because I didn't have access to a computer at that time, and certainly not one with those languages installed, but I remember spending hours reading about these languages and trying to understand programming and how it worked. I got an inkling of the main ideas, but of course, had no ability to actually implement anything. LOGO is a children's language, and the illustrations in the books combined with their children-oriented lesson plans meant that I actually understand the ideas and to some degree was able to *program* in my head. So programming was to me like chess, another subject I spent lots of time reading about in library books, where you thought through the moves in your head. Like Logo, there was an actual language in chess, the algebraic notation and alternative notation systems that I would read in the books and use to move pieces on the chessboard.
Jumping ahead: I played the Buchla synthesize in college, though of course I had limited knowledge at that time and was probably afraid of blowing it up. Although I've continued to do experimental music over the past 20 years I only started playing a eurorack synth a bit over a year ago. It's an expensive hobby, with each module costing hundreds of dollars, and you need a small handful to even get started. For a long time I was an artist and worked in arts admin and I didn't have the ability to spend this kind of money, so over the years I've used free software on the computer, my voice, strange cheap pedals and effects, affordable midi controllers, and even a cassette tape 4track given to me by a friend.
My current eurorack setup consists mostly of modules from Mutable Instruments and Make Noise. I've attempted to build something like a Bucha Music Easel, a laptop (as opposed to suitcase-size) synthesizer by Don Buchla, notable for a particular sound and approach that eschewed thick synth notes and filtering as well as traditional piano keyboard input. The sound of the Buchla music easel is a beautiful organic sound and the instrument is an intuitive cohesive system. I borrowed module selection from the easel's parts, and added in a tape machine module as well as the Monome Teletype.
### Monome Teletype
That takes us to my current setup. I have the Monome Teletype, a module that is essentially a primitive computer. You plug a computer keyboard into the front of it. It has an input section and two output sections for plugging in cables. You write short little programs which you can save in memory banks. Plugging in cables and sending a gate input will trigger a program to run. For example, you could a have script 1 that is a coin flip module. When script 1 is triggered with a gate signal running in, script 1 flips a coin (metaphorically) and if a 0 comes up, no output, if a 1 comes up, trigger a gate out running into the trigger of my oscillator.
Okay, that's just a very simple example.
The module is programmed in Forth, a stack-based language, quite old language, developed to be small and efficient and simple and powerful. It is particularly useful on small hardware as the language also functions as an operating system and debugger. Straight up, Forth is different from every other language I've used, which are all pretty-much Object-Oriented in how I used them, except for BASH and Fish. There is a Teletype manual, some instruction videos, and even a little tutorial series. But despite my own programming background, I still found it hard to get into the Teletype. You tend to write little terse programs. But one issue is that everyone has their own modules, and Monome Teletype is especially popular with Monome fans with these hardware grids and devices that I don't own and use. Tutorials on youtube are few, and they tend to emphasize these other modules or just weren't clear straightforward tutorials for me. I'm hoping as I practice and make little programs I can demystify and teach my knowledge to others.
## Musical Turing Machines
Tonight I built a minimal primitive Turing Machine. What is the Turing Machine? It's not the device described by Alan Turing or the Turing test that's named for him. In Modular Synths, the Turing Machine is a shift register device. It has a number of bits, and essentially plays a pattern of notes. Originally devised by Music Thing Modular, there are a number of manufacturers and implementations. They each work a bit differently. The main idea is that rather than the player creating a small sequence of notes that they repeat, the Turing Machine does it for you. And over time, it begins to drift, as one note at a time slowly shifts to a different note. This makes for a (potentially) calming wave. And since I'm not really a keyboard player, and I love working with generative art and music, I've been really keen to have a Turing machine module. There is one built into the Disting Mk4 a kind of swiss-army module I own, but it is limited, and I didn't love it. I had been thinking for a while about buying one of the turing machine modules on the market, but some are quite large, cost hundreds of dollars, and seemed extraneous since I had this Teletype. Now that I've implemented my own, I'm glad I waited.
My method:
* In the init script, loop from 0 to 10 and push a random note number onto the end of the pattern. Also, you could set the tr.time (length of pulse time for a gate output) here.
* In script 1, when it gets triggered, play the next note from the pattern p.next. This I have triggered by a constant clock cycle.
* In script 2, pick a random index from the pattern p between 0 and p.l (the length of the pattern) and change that note randomly to a number between 0 and 20.
That's it! It's really a Turing Machine demake! But I dialed it in using the clock output on my Make Noise Wogglebug and the Burst output. It produced beautiful slowly driving bell sound output that sounded so lovely I ended up letting it play for about an hour, recording the whole thing. Need an album title: Primitive Turing Machine? Why not.
Going forward, there's lots I can do to extend this. I can use the parameter knob to control the length of the pattern so there are fewer or more notes. Or I can use the parameter knob to increase or decrease the probability that one of the notes in the pattern is changed randomly. I could make a second pattern in init that stores a length of time (maybe 50 to 400?) to pulse each note for each step of the musical sequence. And there's way more options possible. That's only the start.
My code is below:
### Init
This script runs when the scene, which is what we call a collection of scripts, when it is pulled up initially. We loop from
```
L 0 RRAND 4 10: P.PUSH Rand 20
```
### 1
Now we simply take the next item in the pattern and output that as a note in voltage on CV 1 output. I have this hooked up to v/Oct on Mutable Instruments Plaits. In other words, this script is what changes the pitch of a note. Line two is a trigger output, which I sometimes am using to trigger the trig gate input on Plaits and/or Rings.
```
CV 1 N P.NEXT
TR.PULSE A
```
### 2
This script should be triggered less often that script 1. When this runs, it picks a random item from the pattern (between 0 and the p.l aka pattern-length.) and sets it to a random number between 0 and 20.
```
P RAND P.L RAND 20
```
And that's it!

197
programming-forth.gmi Normal file
View File

@ -0,0 +1,197 @@
# Programming Forth
2021-01-20
I have been learning Forth this year!
As a child, I came across Forth in some books, but never had the chance to actually try programming in it. The language lodged itself in the back of my head, and 25 years later I came across it again. The first article that caught my attention was
=> https://hackaday.com/2017/01/27/forth-the-hackers-language/ Forth: The Hacker's Language
by Elliot Williams on Hackaday. The article spurred a lot of conversation: 232 comments on his original post, not to mention plenty of reposts of the article. With that, my interest was whetted. The second article that that stood out to me was
=> https://www.whoishostingthis.com/resources/forth-programming/ Forth: A Weird Programming Language. Here's Why You Might Love It Anyway
by Frank Moraes which extolls its features and links to different implementations and books. And with that, I wanted to really check out and learn the language.
I read some of the books linked, but found entry to the language difficult. I saw occasional mentions of Forth pop up on the Merveilles.town mastodon instance. All of this, plus the idea that Forth has changed very little, that it's a unique minimalist language, that it's a poetic terse haiku-like language, and that it encourages one to shape the language into your own little personal language - all that excited me.
To say Forth is unique is an understatement. It's a paradigm so different from the C-influenced languages I know and use like Java, Javascript, C, C#, even Lua. Working with a stack language is a new way to think. Rather than storing values in variables (which is still possible in a way), one passes the output of a value to a stack. You can do that again. And again. And these values stack up, like a set of stacked index cards. When you need the output, you remove it from the stack, in reverse order from how it was added. I think this is called Last In, First Out? One other unique element is the language essentially runs in a kind of REPL (Read-Eval-Print-Loop) meaning that you write and run your code one line at a time, make some modifications or additions, run it again, and repeat in a loop, building up toward your final output. The whole operating system is made up of this REPL system. You can define what are called words, which are similar to the concept of a function in another language. These words can be remade, combined, and so your program gets built up slowly, built out of these words. Additionally, words are added permanently to Forth, so each person's Forth is essentially a custom build. This is doubly true because while the concept of Forth is computationally simple, there are dozens or hundreds of different variations.
There are many old Forth books one can read to learn the language. I did a search in the App store on my 7 year old iPad mini and found the Jupiter Ace app, an emulation of a circa 1982 home computer that was sold in England. Where most other home computers at that time simply shipped with BASIC, I believe the Jupiter Ace was the only one to ship with Forth instead. Consequently, it was a lot faster, though due to the perception of Forth as more difficult than BASIC, it sold poorly.
The Jupiter Ace emulation app is free. The original Jupiter Ace came with a 186-page manual. The manual assumes the purchaser had no previous experience with a computer (a good assumption in 1982), and proceeds to explain how to type in commands, how to take one's first steps in Forth, proceeding to explain bit by bit to the end of the book how to work with memory, sound, graphics and more. The book is really well written and I recommend it. I particularly found its tone and pace more to my own liking than other dryer Forth texts that proclaim its virtues but not its spirit.
The other Forth intro I'm reading is
=> https://skilldrick.github.io/easyforth/#stack-manipulation Easy Forth
by Nick Morgan. It includes an in-line mini code editor so you can try out code as you follow along. It breaks down learning Forth into clear categories that I found helpful to navigate.
Below are my notes as I'm learning some basics in Forth. I am using my own descriptions and language, not the *proper* computer science description. For example, a professional might balk at my description of a *word* as analogous to a function. Since each Forth implementation may be different, here I am describing gForth, which is pretty easy to install on any system, so if you are learning a different Forth you may have to look up your own language reference.
## Code
#### Stack system
Items, like numbers, go onto the stack, you operate on them, and they come off in reverse order. Even basic mathematics!
Example: `2 + 2` in Forth is written `2 2 +`.
This is known as Postfix as well as Reverse Polish Notation. Incidentally, I looked into whether the *polish* in the title was a pejorative term making fun of Polish people. It's not! It's named in tribute to Polish logician Jan Łukasiewicz who invented polish notation in 1924.
You can add items to the stack.
```
2 10 14 3
```
To print the top item as output and pop it off the stack, you type `.`.
Example:
```
2 10 14 3
. . .
```
Produces the following numbers and removes them from the stack: 3 14 10 ok
Now the only number left on the stack would be 2.
When you hit enter, you'll notice `ok` at the end of a line that runs properly. If your line has an error, you'll get a `?` instead and can arrow over to fix your mistake.
#### Creating a new word
Words are the function or code-blocks of Forth. When you define a new word, it becomes a global function you can reuse. Forth programs are built up of many words.
```
: wordname command1 [command2] [etc] [etc] ;
```
Note the space between your last word and the semicolon
#### Working with the Stack
`dup` - make a duplicate of the item on top of the stack
`drop` - remove current top item of stack
`swap` - swap top two items of the stack
`over` - take item that's second from top, duplicate it so a copy is now on top of stack
`rot` - take element that is third from top and move it to the top (no duplicate this time)
### Output
`.` - remove item from stack and display out on standard output.
`emit` - specify a number and it prints out the associated ascii letter.
`cr` - carriage return (aka newline)
`." [a string]"` - used to specify a string. make sure to include closing doublequote.
### Variables
```
variable variablename
100 variablename !
variablename @
```
The first line initializes a variable memory location named variablename.
Line 2 stores the value 100 at that variablename location.
Line 3 retrievs the value at variablename and prints it to output and places it on the stack.
`variablename ?` is a word defined as `@ .`. It prints out the variable.
`<number> variablename +!` adds <number> to the current value of variable name. like `x+=<number>` in other langs.
Constants never change.
```
<value> constant constantname
```
example:
```
eyeballs constant 2
```
There is no official boolean. 0 is treated as false. All other numbers are considered true, though -1 is the standard.
```
3 3 = .
```
Will produce output: -1, which tells us that this is true that 3 is equal to 3
`<` and `>` and `and` , `or` , `invert`
invert is the same as ! or not in other languages.
#### Conditionals
**May only be used inside definitions**
simple If:
```
: is-zero? 0 = if ." yes" then ;
```
*make sure you leave a space before final semicolon*
If else:
```
: is-negative? 0 < if ." yes" else ." no" then ;
```
And to use it:
```
-2 is-negative?
```
produces yes ok
#### Loops
Forth's do-loop is equivalent to a standard for-loop in C-based languages. Is exclusive of top value.
```
: loop-test 10 0 do i . loop ;
loop-test
```
produces: 0 1 2 3 4 5 6 7 8 9 ok
#### Arrays
No arrays. Instead, you can reserve a number of spaces in memory.
#### Input
```
key
```
It's common to use this with a do-until loop.
## Resources
The Jupiter Ace manual can be downloaded or purchased on many sites. Here is the current
=> https://jupiter-ace.co.uk/usermanual.html Jupiter Ace official site
to download pdf manuals on Forth.
If you're looking for a fast getting started and you have previous coding experience, this 30 page Introduction to pbForth, available on
=> https://web.archive.org/web/20070226214033/http://www.vorlesungen.uni-osnabrueck.de/informatik/robot00/doc/lego/pbForthTut.pdf Archive.org Wayback machine
is a quick intro to Forth, with explanations of how the stack works, variables, words, and more, in a reference-style form. It was written for an intro to using Forth on the Lego Mindstorms power block, in a previous version.
Forth.org maintains an extensive simple to navigate list of
=> http://forth.org/tutorials.html Forth tutorials
(love the 1990s web style).
The
=> https://skilldrick.github.io/easyforth/ EasyForth
by Nick Morgan is an online manual with online mini coding windows so you can try out the commands as you read and learn them.

22
programming-patching.gmi Normal file
View File

@ -0,0 +1,22 @@
# Beginner's mind: Programming and Patching and Synthesizing
topics: generative music, beginning programming, code sketching
I've been playing modular synth now for almost 2 years, though it's really only in the past 3 or 4 months that it's become a daily studio practice for me. Meanwhile, for the past several years I've mainted a daily code sketching practice, where I often (sometimes daily, sometimes.....not) make short little projects: games, generative visual art, strange visualizations, collage via code, and the like.
I've made experimental music in fits and starts for the past 20 years or so. I've been programming for perhaps the past five or six.
One of the reasons I got into playing modular synth is to enter the music hardware world, as opposed to using software. I wanted to make intuitive changes by twirling knobs, hitting buttons. I wanted to hit a switch and things turned on and away I go. It's not quite that simple. It's taken me a good year and a half to fully feel like I am comfortable with the basics of control voltage, which operates very differently from pure audio synthesis. And now that I'm comfortable, I still want to say that there's a lot that's still magical. As I teach intro programming classes at uni, I can tell for many beginner students that there are moments where something works, or doesn't work, and the students can't say exactly why. Often this comes down to syntax issues, though not always. I'm sometimes in a similar place with my modular, and for this reason, I would definitely say I'm not an expert. And in fact, although I do a lot of teaching, I'd probably want maybe 6 more months under my belt to feel like I'm ready to publicly teach a synthesis class.
But the process of creating music on my eurorack almost daily for the past 3 months has paid off, and I've made rapid improvements to my music output as well as my understanding and my studio workflow. I have a flexible and intuitive ability to rapidly make music and little experiments now, so things have almost switched to where I'm more comfortable on the synth and wish coding could become even more like this. When you do a few lines of experimental code sketching, you MAY create something beautiful. But more than likely, it may just not run. You start with debugging. In hardware synthesis, when you turn on and plug in a cable or two, even if it's not beautiful, it's something! There's sound. And you can immediately patch in a cable and filter the sound or modulate it for example.
We can try to replicate this by having prebuilt libraries, functions (aka "base code") to be used in our code sketches. A modular synth approach to creative coding can be found in Max/MSP/Jitter for example, or VVVVV, or TouchDesigner, or PureData, which are all node-based 'patchable' environments for creating interactive art and music. Max's roots go back almost 30 years, and were originally audio patching only, though includes visual tools. VVVVV is a younger development environment, which has taken hold in Europe. TouchDesigner is a more commercial tool, also patchable, used for stage, concert, installations, or corporate 'activations'.
Glitch.com is a current corporate website with development environment, the ability to share and collaborate on code and to deploy to a server. Though not an art and music-focused environment per se, it can be used for creative coding, by using the p5.js library for example, or Hydra for livecoding as another example. I mention Glitch.com because one thing it does well is support the idea of starting with base code. You can browse someone else's or your own past hosted project, then click remix to make a new copy of this running program that you can then modify and see updates live in the browser. It's a nice way to work. It's still not quite as instant as turning a knob in a modular synth, but it does speed up a bit our previous process of write code, save, wait for server to notice, re-render/display.
To be honest, I haven't put enough time into Max to see if it is a good translation of hardware synthesizers into a soft similar coding environment. When I try to use Max, I simply don't know all the possible commands that are available, and how to plug them together. It's not quite as visually obvious to me what to do the way a synth is when laid out in front of me. But people do share their Max patches, and you can copy and paste them in. Maybe it's time for me to become a student and learn the basics. Then I imagine I should try out PD (PureData), its open-source cousin. I've found it fairly intuitive to jump between the basics of object-oriented programming languages. Perhaps jumping between these two won't be that difficult either.
To wrap up here:
Hardware where you have the full ecosystem laid out entirely in front of you can be overwhelming but at least gives you the full map of potentialities. There is a built-in "starter" when working with hardware that is nice to try replicate when working in code. All of these things take time to learn; you're not an expert when you first start. But expertise is not necessarily the goal at the beginning: developing some kind of ongoing practice of expression is the goal. From this practice gradually over time one develops the intuition that's needed to be a better practitioner and creator.

62
short-review-of-clients.gmi Normal file
View File

@ -0,0 +1,62 @@
# Short Reviews of Gemini Clients
2021-01-19
These reviews are possibly not going to say much because honestly Gemini is mostly JUST TEXT and a stylesheet, at least in my mind. So if they don't crash and look okay and are easy to navigate/use, that's 99% what I'm looking for.
This post is subject to change because we're still in a nascent period and I expect flux in the spec and ecosystem this year.
I have a Linux running Ubuntu, a Windows machine, an iPad and a handheld pocketChip Linux computer and access Gemini on all of these!
My favorite clients are Amfora (CLI) and Kristall (GUI). Details below.
## GUI Clients
### Kristall
I like the aesthetics of this one. There are nightly build binaries that can be installed. Super simple aesthetics. Have a 1 or 2 month old binary and still works fine. Simple. Recommended. Tested on Linux and Windows. My go-to if I want a GUI app. Kristall supports Gopher as well, but I haven't tried it. Okay, here's why I also like it: It serves good ole' (bad ole') http and https, which means when I want to view the other web, I can do so, free of javascript, and get this minimal calm web. Seriously, it's very relaxing! It's also nice to be able to follow http links from Gemini pages within the same app.
## What I didn't try and why
I chose a GUI client honestly by first ruling out trying anything where I'd need to install a whole programming language environment. I don't code in Rust or Go lang or Racket. This wouldn't be a problem except that a number of GUI apps require these 400MB+ installs for the language, and I just don't want to install that just to use a simple Gemini client. So if the program was in one of these languages and there was no Binary, I didn't try it. That's why, for example, I didn't try Castor even though it looks nice.
I mostly use Linux, so didn't try out Lagrange which is pretty much new this past month and has simple builds / instructions for only Mac and Windows. But it does look nice, so perhaps will try to install dependencies and build from source later.
## CLI Clients
Both Bombadillo and Amfora are preinstalled on the Ctrl-C.club tilde instance that I'm a member of but I use them on my own computer as well.
### Amfora
This is the commandline client I use 99% of the time. I have tested on Ubuntu, Debian, over ssh, and have installed it on my tiny handheld PocketChip Linux computer (similar to a raspberry pi, maybe about 4 years old at this point). And it works well on all of them. It's blazing fast. The colors are nice out of the box, though can be configured. The dev is very responsive online, though I've never needed help/complaints. Took me a try to realize the controls. Type the number of any link if it's less than 10. If it's more than 10, hit spacebar, then type the number and enter. Alternatively, you can hit spacebar and type in a full link. Bookmark is control-D. Back is b. I think that's all you need to know. This will make more sense if you open the app. Help is ? and esc to quit the help. I really like this one. It even has tabs if you want to use it, and is easy to jump between tabs.
Built with Go and Python but you can download a binary and install was simple. Just chmod +x and you're good to go. There are also packages if you prefer to install via Homebrew, Pacman and K1ss but not yet Aptitude.
### Bombadillo
It's fine, but I didn't like the nav and color/design as much as Amfora. It does allow Gopher, but I haven't felt a need to browse that.
### AV-98
A test client by the creator of the original Gemini spec, Solderpunk. This is the least-bells-and-whistles way to browse Gemini and yet it works fine as well. Took me some time to figure out navigation. I use this on the commandline running Alpine Linux virtualization on my iPad, but it's been over a month so I guess I don't love this. If text is over a screenfull in length you probably want to run the less pager so you can read the full post, and then q to quit. I haven't used this in a while so I can't remember the command to open a link. I think it was b to access bookmarks. I don't remember. You'll have to look it up, sorry.
### Didn't try
Asuka - required I install Rust to build. No.
Elpher - I don't use emacs.
## iOS Clients
### The Gemini Browser
A generic name. Originally available on TestFlight. I really like this one. It's built on a fork of Firefox and manages to feel native to the device, not in a bad way. Only issue I've had is the app sometimes seems slow to load a page, but I just downloaded new version recently and this problem seems to have decreased. One thing I really like: the colorscheme. Rather than user-selectable stylesheet options, the URL of the gemini site you're visiting is hashed and that's used to generate the background color. They are light pinkish-greenish-yellowish and occasionally blue-ish. I'm not doing the description justice. I love the look. The fonts are clear. This feels like a nice simple iOS app. I prefer to read NPR and CNN on here via a http bridge.
### Deedum
New to the scene this month. Feels a bit default tech-y aesthetic to me. Nice feature: Click the clock icon to be able to jump back to an earlier site you viewed. Overall, couldn't get over the generic web app aesthetic. It was neither the 90s vibe nor a contemporary slick design but rather an ugly "default blogger" vibe that I couldn't jive with. I'm willing to try again though and it's nice there are a few options on iOS, but I won't be using this.
### Didn't Try
Rocketeer is available currently on the TestFlight app and requires a newer version of iOS than I'm able to install so I didn't get to try. I emailed the developer and they were sympathetic though.