Ask HN: Does anyone use sound effects in their dev environment? | Hacker News Reader

Ask HN: Does anyone use sound effects in their dev environment?

234 pointsjack_riminton327 comments

It occurred to me that we often use colours in our terminals and code editors to highlight test failures, linting errors etc, but we don't typically use sounds. Has anyone integrated sound effects in any way?

View on HN

From [1] The story of PING:

  ping goodhost | sed -e 's/.*/ping/' | vocoder

He wired the vocoder's output into his office stereo and turned up the volume as loud as he could stand. The computer sat there shouting "Ping, ping, ping..." once a second, and he wandered through the building wiggling Ethernet connectors until the sound stopped. And that's how he found the intermittent failure.

[1] <https://ftp.arl.army.mil/~mike/ping.html>

That is like the beep for continuity testing that is provided by most electronic multimeters, which is very useful because both your hands and your vision are occupied with the tested equipment.

Most older DMMs. Modern ones synthesize a steady or intermittent tone in response to steady continuity. Older ones just use an instantaneous voltage threshold, which is much better for diagnosing an intermittent connection than the newer style, where the tone generator inadvertently does so much time averaging as to be useless outside steady state.

I keep a 30-year-old Triplett around more or less just for this reason. My Fluke from 2019 is much better at everything else, but...

That's the kind of engineer I like to work with!

macos has the "say" binary which is fun to play with for stuff like this

I did something similar for finding which outlet a breaker went to. I connected my MacBook to the outlet, airplay to the TV so it was loud, then had it yell if the power was disconnected:

    while ! pmset -g batt | grep 'discharging'; do; echo waiting; sleep 1; done; say disconnected

a billion years ago I piped say and some various noise files into ffmpeg to make audios that sounded like numbers stations, I don't think it would run anymore but it was a lot of fun :D

That reminds me of the Say tool on the Amiga almost 40 years ago: https://en.wikipedia.org/wiki/Amiga_music_software#Speech_sy...

https://www.youtube.com/watch?v=xr5IFzGiTEk

Back in windows and powershell days, this was my favorite "security reminder" prank. Everyone who forgot to lock their machine and walked away got this script executed on their machines. TLDR: it schedules a task "Security Reminder" to play "I'm watching you" via voice synth, every 30 mins.

```

$action = New-ScheduledTaskAction -Execute 'Powershell.exe' -Argument '-NoProfile -WindowStyle Hidden -command "& {[System.Reflection.Assembly]::LoadWithPartialName(""System.Speech"") | Out-Null; (New-Object (""System.Speech.Synthesis.SpeechSynthesizer"")).Speak(""I''m watching you"")}"'

$period = New-TimeSpan -Minutes 30;

$trigger = New-ScheduledTaskTrigger -RepetitionInterval (New-TimeSpan -Minutes 30) -RepetitionDuration (New-TimeSpan -Days 1024) -At 9am -Once

```

You can imagine people faces, especially many were sitting in headphones in open space offices. Those were the days...

I often use this when i want some feedback from a script somewhere running on my machine but don’t know where output is going

Love it! I use a similar Powershell script for testing cabling/changes. Laptop left on in middle of office with speakers turned up. So handy.

Also reminds me of that old website where people could send text messages to (before Twitter existed).

There was this story of a person who could ping a machine and he knew it was in his house, but for the love of God couldn't find the machine. It's a very short story, but he ends up looking at the pings not knowing where this machine is runnning.

This sounds like https://bash-org-archive.com/?5273 (original website no longer exists).

Mac version, courtesy of chatGPT: stdbuf -oL ping news.ycombinator.com | grep --line-buffered -o "[0-9]* bytes" | xargs -I {} say "Ping {}"

  ping -a

to keep it simple: `ping news.ycombinator.com | xargs -I% say ping`

This sounds like an idea borrowed from games or other media where doing certain actions results in an audible feedback. This is often done for the benefit of the audience, or to enhance the gaming experience, but I had an idea to implement this in my workspace to somehow influence my brain and make it more enticing to write code and somehow beat procrastination.

I wrote a Python daemon which on startup loads small .wav files into memory to make latency as small as possible, and listens for interrupts as well as reads from a fifo. Other programs can send commands to it to play certain chimes on demand. In ~/.vimrc I added autocommands on certain actions - buffer write, enter/exit Insert mode, enter/exit command line, text change, etc. to send commands to my daemon. Now, when I use vim, I get audible feedback of my actions during writing. Since this is all in a separate daemon done in an UNIXy way, adding support for this in other applications should be easy enough if I want to.

If there was interest, I think that I could clean up the project a little and publish it, including a set of free .wav chimes to use.

Related: Juice is the non-essential visual, audio and haptic effects that enhance the player's experience.

https://garden.bradwoods.io/notes/design/juice

Recently I added sounds to a website that fall into this non-essential but experience enhancing (imo) category. I've had somewhat mixed response to this, from total annoyance to utter delight. I'm really not sure what the best approach is to take with sound on the web.

edit: Sounds are present when opening the console, or dragging a canvas around

https://stripe.dev/

Thank you for this fantastic link! Seriously. Bookmarked and planning to share. :)

The old SGI IRIX workstations had sound effects. (the OS is featured in the original Jurassic Park film with the very silly 3D file manager)

It was literally like the hacker movies and predated most of them. Keystrokes, button presses, everything made a little noise. My first boss talked about the horror of the university computer lab full of them before they turned all the sounds off (as well as the absurd cost of outfitting that lab).

With a daemon approach and clever integration within applications that handle missing fifo correctly, all you need to do to get rid of the sounds is just stop the service. And it's also configurable, so you can set what actions actually do produce sounds.

Sounds cool. I'm definitely interested.

Were you procrastinating when you wrote this?

The project is up on GitHub, here's Show HN: https://news.ycombinator.com/item?id=41577391

Maybe. :-)

Yes I’m very interested. I had exactly the same idea, but solved it using the “say” command and a random grab from a set of strings.

I’m a Python dev and I’m happy to contribute to a project is you get it started.

I'll set it up on GitHub in 1-2 days and publish it on Hacker News.

I'd love to try this out, do you have a name for the project so I know how to search in a later date?

The project is up on GitHub, here's Show HN: https://news.ycombinator.com/item?id=41577391

I think I could use a sound when I switch modes in Helix. Thank you for looking into this!

I am interested to give this a try if you share.

I’d love to get this for my own machines.

Count me in as interested!

Definitely interested

I would be very interested, potentially for future commercial purposes.

Something I have often thought about for years but never implemented was "sound logging" where you get specific points of your code to play audio clips or tones instead of/as well as logging to console etc.

The idea being that you can test the app.and hear the sound logs going off as you go. In a tight loop that executes quickly I would hope that you could hear something "being off" in the same way that a mechanic can hear if an engine is "running rough" etc.

Of course... It might just be a totally inscrutable and useless wall of noise too! Won't know until I try it out

Xcode has this functionality. You can attach a system sound to a breakpoint. I used it exactly once when I was trying to determine if two events always happened in the same order and were always equally spaced in time. It worked well but drives you sort of mad after a while.

One interesting way of using this I've heard of; is attaching it to a `-[UIViewController dealloc]`, and being able to "hear" (or rather notice the lack of sound) retain cycles this way.

Xcode has all sorts of cool stuff you can do with breakpoints, one I used more often than sound is logging a value on a breakpoint and continuing execution.

This was my undergraduate "thesis" project. We built a GDB plugin that would generate a puredata audio structure to help with debugging. Eg. it would play snoring during a sleep() call, each breakpoint could be set to a different frequency, etc. It was actually pretty interesting for multi-threaded code, though pausing to play the audio could change the runtime profile.

I recall seeing the following very neat idea on HackerNews some time ago, but can no longer find it:

The idea, if I remember correctly, was to intercept system calls and play a sound every time one occurred. So you'd get a series of beeps every time the disk was accessed, somewhat similar to the spinning noise from HDDs. It would play a different type of noise every time the network was accessed, memory was allocated or freed, and so on.

They reported that developers got pretty good at diagnosing and debugging their programs, purely from listening to it run.

I had the exact same thought for years but never came around experimenting with it. I also hoped that one could eventually hear that something is off.

I think this can happen by either recognising the "rhythm" in which sounds appear and/or recognising different tones.

As a first step, my idea was to write a logger that plays different beep sounds for different log levels. That way you could mostly identify the “rhythm” because I guess most log messages would have the same severity. However, to a tiny degree also by the pitch of the sound.

Then as a second step I thought of mapping the log message to a scale of sounds by e.g., hashing the message. This obviously would only work if there’s no dynamic content in the message.

I definitely chain things like "make; say all done", then crank the volume and go make a snack. But that's probably not what you were referring to.

A bit late to the party, but I had a similar idea a while back and built a prototype of this here: http://pilliq.com/companion

It's a "runtime" that executes arbitrary JS code while continuously playing a single tone. Every loop iteration increases the tone's frequency, and every recursive function call increases the tone's pitch (when the function returns, the tone's pitch is decreased).

  * There are visual markers to show what is currently being executed
  * You can increase or decrease the speed of playback
  * You write your own code and execute it in the browser.

I included two examples of fibonacci: one that's iterative and one recursive. I think the audio/visual feedback helps you "feel" the difference of why the iterative implementation is faster than the recursive one.

It's a bit of a hack, and you may need to refresh the page after it finishes running through the code once.

Makes me think of movie/TV computers that beep and bop, e.g. https://www.youtube.com/watch?v=hsP-kWvl1ds

An out of place beep would probably be noticable.

It could be useful but it would probably be very annoying and disharmonious unless it's very well designed. Would be cool and potentially very useful if somebody incorporated it in a good way.

The Grep Console plugin for JetBrains IDEs lets you do this.

It isn't exactly what you have in mind, but I use `play` as well as a terminal theme color change to tell me when I'm using one or another language's keyboard layout. If you put & in front of play, you can make chords.

Here's an example:

    # Define notes for major seventh chord starting on A 440
    A=440
    C_SHARP=554.37
    E=659.25
    G_SHARP=830.61

    if [[ "$layout" == "Finnish" ]]; then
      # Play a major seventh chord ascending
      kitty +kitten themes --reload-in=all Apprentice &

      play -n synth 0.2 sine $A vol -30dB &
      play -n synth 0.2 sine $C_SHARP vol -30dB &
      sleep 0.2
      play -n synth 0.2 sine $E vol -30dB &
      play -n synth 0.2 sine $G_SHARP vol -30dB &
    elif [[ "$layout" == "English (US)" ]]; then
      kitty +kitten themes --reload-in=all Default &

      play -n synth 0.2 sine $G_SHARP vol -30dB &
      play -n synth 0.2 sine $E vol -30dB &
      sleep 0.2
      play -n synth 0.2 sine $C_SHARP vol -30dB &
      play -n synth 0.2 sine $A vol -30dB &
    fi

Forking each sox command to the background causes samples to play non-deterministically and step over each other. Here's a better way:

    # Define notes for major seventh chord starting on A 440
    A=440
    C_SHARP=554.37
    E=659.25
    G_SHARP=830.61

    case "$layout" in
    Finnish)
      kitty +kitten themes --reload-in=all Apprentice &
      play "|sox -np synth 0.2 sine $A" \
           "|sox -np synth 0.2 sine $C_SHARP" \
           "|sox -np synth 0.2 sine $E" \
           "|sox -np synth 0.2 sine $G_SHARP" \
           vol -30dB 2>&- &
      ;;
    'English (US)')
      kitty +kitten themes --reload-in=all Default &
      play "|sox -np synth 0.2 sine $G_SHARP" \
           "|sox -np synth 0.2 sine $E" \
           "|sox -np synth 0.2 sine $C_SHARP" \
           "|sox -np synth 0.2 sine $A" \
           vol -30dB 2>&- &
      ;;
    *) echo >&2 'Invalid $layout - must be "Finnish" or "English (US)"'; exit 1
    esac

Relatedly, I once saw someone realize that the sound they played at the end of their build was running synchronously so they were blocking themselves from a faster feedback loop and reporting unusually long builds in their profiling. Properly backgrounding the sound fixed their issues.

Stepping over each other was the point! :) But very good to know if I ever want to encode a little melody instead!

I used the same approach when programming my fridge. If the compressor was required because the temperature in the topmost shelf was too high, the tones would play in rising order. If it was due to the bottom shelf, then the tones would play in descending order.

I ended up disabling the feature because it was always the bottom shelf.

Is your fridge on GH? Mine is outdated and I'd like to download a newer one.

When I read that Finnish was a major seventh I was hoping that English would be a minor seventh or something even more subtly different. A minor 7th vs a minor 7 flat 5 etc.

Would be funny to create an elaborate system of notification tones that are only discernible by a trained musician

> Would be funny to create an elaborate system of notification tones that are only discernible by a trained musician

Oh man, could this concept be turned into an esoteric programming language where to program you use a musical keyboard and all the symbols in your lang are different chords or intervals

Absolutely no visual feedback for extra pain

Forgive me Mr. Ghost Pepper. I didn't take the ear training seriously enough in AP Music Theory, and now I can scarcely tell my eleventh chords apart when I'm listening to Charles Mingus!

It's not a dev environment, but when I have been observing at large (inter)national telescopes, there are often a variety of sound effects in the control room. These sounds often announce a change in status (e.g., observing script started, observing script finished, script failed, script added to the queue).

One example is the Atacama Large Millimeter Array, that in practice is three separate arrays of telescopes (an array up to 50 dishes that are 12 meter diameter, an array up to 10 that are 7 meter diameter, and another up to 4 dishes that are 12 meters in diameter) that are observing different targets at the same time. Each array has its own kit of sound clips and after a few sessions it becomes second nature to identify which array needs attention by the sounds coming over the speaker. "Uh oh, looks like there's gonna be trouble!" followed by another announcement that the script was terminated. Then the array operator works on recovery while I would see if the script should be re-started or if weather conditions had changed enough to warrant a different choice of observation.

Similarly, optical telescopes often have audible alerts when integrations have finished and the data are being read off of the CCD/sensor.

Correction: there are up to 12 of the 7 meter diameter antennas.

In around the year 2000, for career day I went to work with my uncle. He worked in IT for General Mills. Their office was very much a stereotypical poorly lit IT cave in the basement.

All their computers were a constant barrage of custom pop culture sound effects for every action. Minimize a window and a computer would emit like a "Ooh baby" clip for instance. Place had the tone of a morning radio show. Seemingly every action you could attach a sound effect to, they had. It would drive me insane trying to work like that.

Tech culture is very different from what it once was.

I worked at a help desk one summer and every inbox had a different sound effect. We had several different external customers each with a dedicated machine to handle their tickets. The most critical customers (i.e. the biggest fines) got the loudest, most annoying sounds. Everything was an animal sound so the place literally sounded like a zoo on busy days. The manager absolutely hated bringing various big shot tours through our call center because of the ridiculous noise but we also had a perfect record.

One of my first experiences with our home PC's was downloading wav files of movie and TV clips off of AngelFire and GeoCities sites and assigning different windows tasks to play them to prank my dad. Error dialog popup? Beavis and Butthead's "Breaking the law, breaking the law". Out of disk space? Johnny Mnemonic "I can carry nearly eighty gigs of data in my head". He thought it was hilarious and would reassign them to his own clips that he found and we continuously tried one-upping each other to find the most annoying possible sound for every windows function.

I worked for a woman who had the Microsoft helper (like Clippy) but chose the cat avatar, and it would meow ALL day. It was funny for about 2 hours and unbearable beyond that!

Well, that's one way to get rid of open floor layouts.

In my collection of CDROMs, I had one titled "Wired For Sound Pro" -- it was some custom software that could add sound effects to a ton of Windows events, as well as a huge library of sound files to attach to those events. I think products like this were to showcase "Multimedia PCs" that were starting to make it big in the mid 90s...

This could be kind of fun if done in moderation. Maybe a git hook that lets the creator of the PR select a song to play over the speakers when the merge request goes through. Some people might get pissed off, but I think it would be nice to have a bit more whimsy in software dev. As long as everyone is on the same page, should be fine.

Yes, this.

Imagine an elevator, gas pump, vending machine, or laundromat emitting sound effects constantly.

Quite the dystopian hellscape.

> gas pump

Most of them play advertisements while you fuel up. I hate it. The only thing that I like about New Jersey forbidding me from touching a gas pump is that I'm not subjected to ads for diarrhea medication or low-APR loans every time I fuel up.

>Imagine an elevator, gas pump, vending machine, or laundromat emitting sound effects constantly.

This a non-that-inaccurate depiction of how life in Japan is, but thankfully one adapts quite quickly to that.

Just wait until they integrate the devices with AGI + TTS and either tie it to your ad history or one-click purchasing.

AI Fridge: "We noticed you're almost out of cheese. Would you like to make your dairy extraordinary today with Tillamook Sharp Cheddar? Say OK to order now!"

Enfleshened One: "No. Please self destruct."

AI Fridge: "...Take that back, or I'll wilt all your lettuce."

https://github.com/kristiandupont/react-geiger

This plays a click when React components rerender, to make you aware of the page performance

This one does the same thing but with beeps, with higher pitch for heavier DOM updates. It’s not as nice as the geiger click but I’ve found it more useful for figuring out exactly where the UI is slow.

https://github.com/tomhicks/react-audible-debug

Cool! Found this little video of it in action https://www.youtube.com/watch?v=bM_DrpCK5i0

I'd love one for React-native, might look into making one if I don't find any :D

I think in case of React the core idea is simple. For example I would love something like this for Rails ActiveRecord to help you find n+1's by sound

This is so cool haha

One of my friends old office had speakers and every time Jenkins failed with a build it made a short sound. It was different for each project so everyone familiar with the sound would instantly know which project pipeline failed. He liked it and had fun choosing a sound effect fitting for his own project :)

One place I worked at the success was a golf clap. The fail was crowd going 'awwww' as if someone had just missed a putt. Nice and simple. Since the build took 3-4 hours you did not hear it much.

Before everyone went 'open office' it was semi fun to have sounds on different build actions. Now not so much :(

There’s… a particular sound pack that had those two sounds. Maybe different ones, sure, but this just unlocked a memory of two very particular sounds from my early Windows days. Might have been built-in, or maybe from Microsoft Plus.

I sat next to someone who had a similar set up, except a robot voice also read out a summary of the failures.

I moved desk within a few hrs.

Sometimes when I wait for slow tasks to complete I do stuff like:

  sleep 900; say "Task X is probably done now"

On Mac this works out of the box, AFAICT Linux has similar commands.

https://ss64.com/mac/say.html

https://manpages.debian.org/bookworm/gnustep-gui-common/say....

I use something similar with an added "nagging" functionality. Surprisingly, it's easier for me to obey this thing, than nagging from an actual human being.

    nagme () {
        [ "$#" -ne 2 ] && printf "usage: $0 [in_minutes] [text]\n" && return 1
        printf "sleeping $1 min before telling you to $2\n"
        sleep "$(echo $1\*60|bc)"
        say "$2" > /dev/null 2>&1
        while :
        do
            sleep 30
            echo -n '.'
            say "I'm nagging you to $2" > /dev/null 2>&1
        done
    }

I used this for my pipeline that deploys a fresly baked raspberry pi image onto an SD card. It would remind me to remove the SD card and put it in the Pi, boot it and have Ansible continue to configure it. Felt awesome.

I do this, but I put it after terminal tasks like builds or test suites like task build; say complete

thank you.

Just created an alias

alias waitfor='f() { sleep $1; say "Task $2 is probably done now"; }; f'

Why an alias creating a function and running it, instead of just defining the waitfor() function?

    function waitfor(){ sleep $1; say "Task $2 is probably done now"; }

Not sure if more people have that but I hate sounds. I turn off all system sounds on my OS. I turn off all notifications on the phone.

It is not like I get called often but still had bad memories from former work where everyone had the same phone and the same sounds and I was often working 24/7 support. Hated that work and hated my morning wake up alarm that I had to change every couple months because each one I hated more and more the longer I used it.

I love melodic music and also any sounds not aligning to melody or rhythm are super annoying for me especially if I get into the flow.

Yup me too. I read some scientific paper which I cannot find recently that some low percentage of people get annouyet by repeating predictable sound patterns and I definitely belong to that group.

The classic audio diagnostic on Linux/Unix is some beeps occurring and kernel debug text on all virtual terminals when something really horrible has gone wrong.

If you want to make a beep in a linux console, try adding this to your shell scripts. It should trigger the default system "beep" sound. I used to include this in my scripts that ran really long tests or cluster jobs to wake me up and check the results.

Sadly, on many laptops and PCs today, there seems to be no action on the PC speaker at all, but you can configure this system beep code to trigger a sound of your choice from your favorite gui console application.

In Python I believe you can trigger the system 'beep' sound with one of the following: print("\a") # cross platform print('\007') # linux only

My gui favorite, Konsole does not make any sound using these standard methods unless you manually configure it to play a file for "Bell in focused session" under Notifications. Of course this plays a wav/ogg file instead of triggering the PC speaker.

It can be really hard to make a little beep these days, when you consider you may have 4 different sound outputs (one for each display and video card, one or two for the motherboard), application specific audio levels that get set to quiet or muted by default arbitrarily, and then application specific opt-ins needed just to support a little sound that was kind of a failsafe notification in earlier times.

I remembered as I enabled this great setting, that I am usually very quick to turn it OFF because it causes the configured sound to play when you hit backspace at a blank prompt, which I tend to do when I'm thinking of what to type, or clearing lines, I just hit backspace excessively for fun. Unfortunately the bell causes me to get penalized for that, so I will probably disable it again.

Surel backspacing beeps at the empty prompt can be turned off. I feel like I do it all the time.

Peep:...

Abstract

Activities in complex networks are often both too important to ignore and too tedious to watch. We created a network monitoring system, Peep, that replaces visual monitoring with a sonic `ecology' of natural sounds, where each kind of sound represents a specific kind of network event....

https://www.usenix.org/legacy/events/lisa00/gilfix/gilfix_ht...

(not my work; that of a former co-worker)

Came here to say this. I remember seeing Peep on freshmeat.net back in the day, before SourceForge took it over. Seemed like a very cool idea and I played with it for a while, but my coworkers didn't care for it.

Here's a recent discussion here on HN: https://news.ycombinator.com/item?id=33017337

I do. I have a small Swift HTTP notification service running on my dev machine, that uses SimplyCoreAudio to locate a specific speaker (so that notification sounds aren't affected by connecting headphones or speakers) and play a custom NSSound specified by the request. And I have all kinds of scripts calling that notification service on completion/error/specific conditions met from anywhere on LAN. The service also optionally shows a desktop notification dialog (through osascript app.displayDialog()) and/or send a Pushover notification to my mobile devices. Try it, it's a great way to wait for asynchronous tasks.

I sometimes use sounds as opposed to print statements when debugging automations or certain UI behavior, e.g. to indicate whether a certain if-condition was triggered or not.

The advantage over normal print debugging is that you get immediate feedback, and do not need to switch to a console. This is also useful when it comes to debugging split second timings (custom window movement scripts).

You just gave me the idea for a tool that watches log files and plays sounds when certain patterns occur.

Yes! I wish there were better tools for getting sound out of the terminal.

I got bored waiting for long running scripts to finish one day and wrote this bash one liner.

Now I can run a command and put a pipe and the zzz alias on the end and it will tell me when it’s finished.

> alias zzz='echo "zuhg zuhg\n" "work work\n" "lowk taar\n" "jobs done\n" "sawobu\n" "dabu\n" "i can do that\n" "be happy to\n" "OK\n" "no time for play\n" "my life for the horde\n" "what you want?\n" "master?\n" "dabu\n" "for the horde\n" "okie dokie\n" "hragh\n" "something need doing?\n" "ready to work" | shuf -n 1 | say -vRocko'

Upvote for the excellent Wacraft II reference. Those are some of my favourite sound effects, and they are often quoted among my friends.

Here's all of them: https://www.youtube.com/watch?v=gntGbsmTY_E

And don't forget the last track on the CD: https://www.youtube.com/watch?v=RwWh1xy6gvU

If I am running a command that runs long enough such that my attention will drift but short enough such that I can't start something else, I'll append `echo "\a"` or equivalent. It's nice to know when the command completes.

Loosely related, I am almost always running some white noise into my IEMs.

On osx you can use `say "long command is done"` or whatever is descriptive.

I’ve tried it, and since I work remotely the voice is too surprising for me.

I use this, which I use for exactly those kinds of scripts, but I don't really like noises: https://github.com/julienXX/terminal-notifier

This is a feature built into warp, which is kind of nice.

The dude in the cubicle next to mine used to use sound effects extensively, but he died a mysterious death a while ago...

Choked on a speaker?

No idea what you're talking about...?!

In highschool my friend wrote a mIRC script that waited in our city's DALnet channel for someone to announce they were *\f\(our city), and would DM them hello, start a conversation and if they responded the script would announce "babyfaceangel16 is female".

He'd turn it up and go play N64, and occasionally his computer would announce he's in a conversation with a girl so he'd drop the controller and pick up the conversation.

The dating game has always been a lot like fishing. Did he ever get a real date this way?

Yes, and if I remember correctly at least one girlfriend for a few months

Yes! I play a “bonk” sound when a command in my terminal fails. Helps me break out of autopilot up-enter-up-enter loops that I can do accidentally. I wrote a blog post about it a while back: https://cgamesplay.com/post/2020/12/09/iterm-notifications/

`$ ... && say 'Notice me father, I am complete'`

(something I add to longer scripts when the job gets particularly boring)

say "The dishes are done man"

however, turning off the damn bell in my terminal is a must. I hate whenever I'm trying to tab complete and it doesn't find anything and plays the bell. Hitting tab is instinctual for me, and I do it much more frequently than I would guess.

i tried d&d during the pandemic and was taught what 'flavor text' is. a dictionary of one to many flavor texts would benefit me using this pattern because i need randomness to break through the anticipation. in fact, mapping to posix exit codes would probably be the only case i'd use - give me 1000 cute sayings for exit 0, and a dozen for 255, 1, 2, and a sensible default.

preemptively, to anyone telling me this is terrible, i'd say this is a toy and a subjective one, but that we're detailing our personal flows here, and not inventing interfaces :)

This actually sounds like fun.

A lot less "Las Vegas video slots parlor" because of the randomness.

I play different wav files when compile fails or succeeds, so I don’t need to switch to terminal from the editor. This in addition to Anybar(1) red/green icons.

1. https://github.com/tonsky/AnyBar

I've heard of using "Geiger counter allocators" -- custom allocators that make a small click whenever an allocation happens to get a sense of when a program is doing lots of allocations, especially lots of small allocs, as it's running.

I once configured a Jenkins instance to play different sound effects when certain builds would fail. Originally these were played out of our big office TV, but its speakers broke at some point. A few years later, a couple of new hires came up to me to tell me they thought their laptops were infected with malware, because it would sometimes make weird noises. Turns out they had Jenkins open in a browser tab, and it would play the sounds when builds broke.

Lots of generational differences here: A opened the build while I’d just wait for the email in case of failure. Second, they kept it open, which in my time I wouldn’t have (Perhaps you neither, which would explain why you never noticed).

I used to work at a company where running the full test suite took about 10min on my local machine. I would often run

    ./test.py; beep

where beep is a script I made that plays the Macintosh boot beep[1]. It was pretty useful.

I also did something similar that one time I had to compile LLVM (~4h on my laptop) and that other time I had to compile Firefox (~6h on same laptop).

[1]: https://ieks.cc/articles/mac-beep.html

Terminals have supported a bell since terminals existed. The moment I hit tab on an interactive shell and it bleeps, I make sure it never does that again or my SO can't sleep.

When I've had longer-running test/lint suites in the past, I've added simple sounds to the ends of their run scripts (birds chirping for success, alarm blare for fail) that help me draw my attention back. I had an issue where I would go off and read the news, or social media, or whatever, when running my tests, then suddenly it would be twenty minutes later and not only would I have wasted fifteen minutes, I'd have forgotten what it was I was even doing...

Ages ago, before even dumb terminals, we were programming on punched cards, batch compiling, and printing on a line printer. For some reason, this printer supported control G (the bell character) with a buzzer. So someone hacked the compiler to include control G in the beginning of the error messages.

So we could sit back and listen to the line printer. If the buzzer sounded, the programmer would say "Oh &#$!@". Just like Pavlov demonstrated.

I have made sysm specifically for this: https://github.com/jafarlihi/sysm

> sysm makes your system play custom sounds when any configured system or external event happens

I worked in a quantitative trading company, and the traders would use sound effects for every kind of alert. Each time a risk limit gets hit, a disembodied voice would say "<system name> limits!" or make a pig oink or something. There was a shared folder of thousands of .wav files.

It reminds me of plane cockpits where the system barks out things like "Terrain! Pull up!" if the pilot needs to react instantly.

I suppose quantitative traders use the "Retard! Retard! Retard!" Soundbite for slightly different reasons than airliners

Absolutely not. Cubicle farms are noisy enough as they are. The occasional beep from an ASCII Bel character is more than enough.

I also surprise myself regularly by finding that I'm still wearing noise-cancelling headphones long, long after the Zoom or WebEx has ended. When I take the headphones off, I'm surprised again by how noisy the background is, particularly the howling of the ventilation system.

Oh man, I'm jealous that you get cubicles. When I moved from Big Corp to startup land, I did not realize how much I would miss having a cubicle.

Corps don’t do cubicles anymore either, since the pandemic it’s all open spaces with hot desks

I used to do this as a data scientist. Sometimes training jobs would take an awkward amount of time like 30 minutes or an hour and I'd get sidetracked doing something else. So I just had it beep when it was done like an oven. Prevented me from having to check back every now and then or missing an email. We didn't have good chat integration back then.

I have these that come from history|grep espeak

From a particularly sunny day where I was having too much fun waiting for my builds:

    while ps -49011;do sleep 3;done;espeak "IT'S DONE YOU FUCK. COME WORK.";telegram-send "done"

More regularly:

    gh pr checks 2850 --watch ; while true; do espeak "main done";sleep 5;done

I use a sound effect to notify me about the exit of long running commands

    alias kk
    kk='say "ok! I am ready"'

Usage

    sleep 10 && kk

Not my idea, I found it years ago in some dotfile. But it is kind of handy if you run a long-running task in a terminal in the background.

Almost 20 years ago, Ang Cui and I were bullshitting and brainstorming around an idea he had to categorize patterns in network traffic as audio tones so that one could listen to network traffic flow.

He has since gone on to do other, bigger things and I'm still sitting here kicking myself for not at least pursuing the idea a little.

It was done at Tufts University and presented in 2000 at the USENIX LISA conference https://www.usenix.org/legacy/events/lisa00/gilfix/gilfix_ht...

Alam Turing used the "hoot" instruction on the Manchester computer in the 1940s to signal different things for debugging https://www.bbc.com/news/magazine-37507707

95% of my work (web dev) isn't so much waiting for something to happen, where a notification of any sort would be useful. Most builds etc only take a few seconds, so I just wait.

Most of the work is thinking through a problem, then ensuring it's coded correctly. The colors and syntax highlighting and squiggly lines and Typescript warnings etc (in Jetbrains) are all helpful because they are contextual. "Hey, this function isn't written right" or "you mapped this array to an invalid return type" let me know exactly what I did wrong so I can fix it.

I don't think random beeps and dings and pewpews would have the same kind of contextual usefulness, and would probably be annoying and take me out of the zone whenever I'm focused and coding.

Mostly agree but this does give me an idea: having a sound that indicates a change you just made to a line caused an issue with an offsceeen line. For example deleting the last usage of a variable declared higher up.

Of course there are already onscreen solutions for that, such as indicators in the minimap, but it could be more obvious as a sound.

I agree, that would be nice. It could be like RTS games, where a narrator says something like "Your code is under attack" and there's a ping on the minimap pointing at the exact line.

Sure. I've used `say` on macos (spd-say for linux) like so:

    mvn clean install ; say "Done"

It's great for those build times that're awkwardly long. Just long enough that you get bored waiting, too short to accomplish something else in the meantime. So you crank up the volume, load up HN, read an article and "DONE!" OH HOLY SHI--. Back to work.

that said it sucks to set up that flow when you /sometimes/ are around other people. it's pretty jarring if anyone can hear it, so you just wouldn't do it in a tight-collab area.

Usually though they're SUPER annoying so eventually I weeded them out of my workflow.

Would not recommend using sounds in development.

> it's pretty jarring if anyone can hear it

That's only because you haven't put any effort into sound design. Notification and alert sounds can be horrible like many of the ringtones people choose or they can be pleasant and unobtrusive like certain defaults in various apps. Try browsing some sound effect libraries on various game asset stores, there are many free effects available, and choose something that isn't jarring but is still unique enough to recognize. Avoid sharp beeps and boops or loud melodies, look for ambient sounds like the click of a lock or switch, the swish of paper or fabric, a soft impact sound like dropping a slipper or flip-flop, something you'll notice but won't startle you.

No, I do the opposite. I keep my speakers muted when developing. I don't want sounds. But then, I'm also one of those weirdos who prefers not to use colors as well (they hinder rather than help me), so it may just be a personality thing.

For those interested, Xcode lets you configure sounds to be played when a breakpoint is reached. It can also be set up to conditionally play a sound.

Those breakpoints can also be configured to continue running the app instead of pausing.

It can quickly get out of hands though.

I've avoided XCode thus far, but I'm going to have to see if there's a way to add this by Python scripting LLDB, because there are certain kinds of tracing where sound is probably the optimal medium. It's mind-numbing to try and catch unexpected orderings using printf debugging, and step debugging makes this worse not better.

I'm thinking that for up to five events (which covers a lot of ground) this would be pretty sustainable with the pentatonic scale. Any combination of pentatonics is reasonably pleasant, and it would be very easy indeed to hear a permutation in the expected melody. I think this is something I could keep doing without suddenly developing an extreme aversion to it.

It would still be necessary to use headphones to prevent casuals from being exposed, though. It wouldn't be that melodic...

It can be super useful for detecting the timing or relative ordering of code blocks. Something like “what order are these 2-3 methods called in and does it vary?” is so easy to hear as you navigate through an app.

Or if you’re doing something async / interactive / whatever, and don’t want to stop the app, but do want to know when a code block executes.

I wish it had more short & distinctive sounds to choose from though! edit: I think I found this project while working at a previous job, but haven’t used it recently: https://github.com/matthewreagan/Xcode-Breakpoint-Sounds

I don't personally but then again most of my work is not asynchronous in nature.

A friend of mine has a TSR application that plays sounds to simulate as if they had a mechanical keyboard which they use with their laptop. So that's something.

I use a mechanical keyboard at home and I can absolutely see the 'tacking' sounds that it makes as a form of audio feedback

Same, I was surprised to find out how hard it was to play a sound everytime the word ERROR appeared on my terminal.

I even wanted to run a sound on the "positive case" ie a loop that is processing a few hundred items, could easily benefict from a subtle sound so you could feel when some request got hold...

Like virtually all hardware does ie your vacuum cleaner has something stuck and is not operating at 100% etc.

(I'm planning doing a "toy" terminal using a gamedev environment just to explore this a bit)

edit: If you use Raycast you can just throw confetti from the command line too for extra dopamine:

    open raycast://confetti

Use the ascii bell character "\a" and turn off the "visual bell" or whatever options in the terminal (I hate those things) so you can actually hear it beep and find joy.

Instead of sounds to indicate the end of a long-running task, use a notification:

https://github.com/t413/zsh-background-notify

I noticed that gnome terminal has this built in. I normally use tmux, so the gnome terminal feature does not work for me since the command never finishes in the view of the terminal, but occasionally I'll fire off a command in a regular terminal window and will ReDiscover this. Pretty neat!

I use a pomodoro app that pings when time is up and ticks for the duration if sound is on.

One constraint on frequent sound use is you can only really use them in either a solo environment or with headphones without being antisocial; which is probably a contributory reason to it not being a significant presence in modern development.

I suspect it was a more common thing in the beginnings of home computer use (80s onwards) when creating and controlling sound was immediately available from the command line before programming got abstracted away to a secondary level.

In the depths of the pandemic, James Shore ran a Tuesday TDD Lunch & Learn livestream. He based everything around TDD with an audio addition to the red/green display. Here is an example of the sound:

https://youtu.be/nlGSDUuK7C4?list=PLD-LK0HSm0Hpp-OspFpZ32uY7...

I really like the gentle audio feedback with TDD, so I took the sounds from James' bespoke TDD harness and added it to my jest-audio-reporter.

I can't help envisioning such a thing with *Command and Conquer* announcer or *Warcraft 2* peasants.

"Building ..." "Cancelled" "Unable to comply, building in progress" "Construction complete" "Cannot deploy here"

"Job's done"

etc

https://www.youtube.com/watch?v=HW1qfrx_Lg8 https://www.youtube.com/watch?v=PoMhMZZjbGg

I love this idea.

YOU MUST CONSTRUCT ADDITIONAL PYTHONS

Ugh I want this now.

> Has anyone integrated sound effects in any way?

Terminal bell rings every time I press escape more than once in vim :-)

A while back I prototyped (very roughly) an auditory equivalent to “syntax highlighting”, using ambient tones and white noise, rather than discrete beeps/sound effects. [1]

I’m actually revisiting this project right now! I’m reimplementing it in Rust and also exploring different ways to communicate parser state and other contextual information through sound.

[1] http://marycourtland.github.io/AuralJS/

This doesn't seem to work for me in any browser. No sound.

VSCode is adding sound as an accessibility feature. I am personally not in need of this feature (yet), so I notice when they surprise me with a new sound for a new event turned on by default.

I think I could find value in adding sound to my dev environment, iff there were a quick and easy way to sample and select from collections of sounds made for this purpose.

As it stands, if I don’t like the sound chosen by the audio accessibility group, I just turn it off because there’s no UI to change it.

Once, Apple had Sonic Finder.[1] It was kind of cute. Especially the part where the sound for dropping something in a move was deeper for a larger object.

[1] http://sonify.psych.gatech.edu/~ben/references/gaver_the_son...

It reminds me of Extreme Feedback Device (XFD) lava lamps, pilot lights, and more.

> and more

The best example of which being Retaliation - https://github.com/codedance/Retaliation

My suggestion for anyone wanting to try this is to use small bleeps that don't get annoying over time. I use some retro game sounds by cabled mess[1].

[1] https://freesound.org/search/?q=Retro+Video+Game+sound+effec...

I have `blaze` (bazel) aliased to a command that runs whatever blaze command I'm trying to do and then rings the terminal bell. Any compilation, run, test, etc, all gets a visual and audible notification that it has completed.

This is great for my focus. Even if a build or test is only going to take 10s, I'll still change window to my email or chat. The ping brings me back.

I have a shell alias that I use sometimes when running long-running test suites locally, or doing some long task that is blocking my work (building Docker images, installing libraries). It echoes something for the shell, shows a success/failure image in the terminal, and playes an audio clip (loud and annoying ;)) when tests pass. The only way I could make it better would be to play a sad trombone on failure:

    # e.g. pytest tests/test_foo.py && SUCCESS
    alias SUCCESS="echo -e '\n\nSUCCESS' \
               && bash -c 'mpv ${media}/kazoo.mp3 &' \
               && imgcat ~/Pictures/success.png \
               || imgcat ~/Pictures/fail.png"

It's useful because I can hear that the task is done while I'm reviewing a PR, or reading documentation, or loading the dishwasher.

I don't use anything, but each time my eyes hurt, I wonder if I should: with some sense of music and tones, I often wonder if I could develop enough audio feedback to be able to do tasks like opening apps, writing, compiling, and getting feedback. I also often wonder if that is something that the visually impaired already use.

I'm overloaded with notifications. I don't want any more.

Sure. I have scripts to build my unity game on several platforms, the last is Android which then installs on my phone. It plays Ocarina of Time sound effects upon success or failure, since it can take several minutes, or randomly fail before then. In both cases it's nice to hear immediately that I should do something.

The same sound on success or failure?

Nope. Failure is the minigame gong failure. Success is one of the jingles of success, with five tones that each increase in pitch.

I have scripts that run in the background to check for the health status of some systems I am monitoring. I use a program to display results on my wallpaper and I trigger a "say" command if it fails.

I also commonly use a "say" command to just get notified when a long running command is done.

I once used the Xcode feature to play a sound when a breakpoint was hit. My EM had a conversation with me.

I configured Visual Studio to play sounds if a compilation succeeded or failed (to wake up if it's taking too long). I also configured it to play a sound if a breakpoint is hit (quite useful if you are debugging a game and some assert you don't care triggers)

Sometimes if I'm running some long running task I'll do `; say finished` afterwards so I get pinged when it wrapped up.

At once point I had a slightly more sophisticated command that would check the output and say completed or failed but it wasn't much more useful.

There is React Geiger which makes geiger counter noises on render [1].

Easy to tell when you have messed up and re-rendering tons unexpectedly.

[1] https://github.com/kristiandupont/react-geiger

At a previous job we had a service that handled around 1 query per second.

I crafted a oneliner that `tail -f`'d the logs and played a note for each response. I believe there were different notes for different HTTP status codes but it was years ago so the details flee me.

Interesting, could set the "bad" response codes to be in a minor keys and and "good" as major and feed that into a generative player. Listen to the stream and if it starts sounding moody and broody, check monitoring.

Late to the party, but I have a script called zbeep that takes command and args as arguments. Makes a sound before starting execution and has success and fail sounds. It’s great for those 5-10 min processes. For long stuff I have a similar zslack command.

I use a command that'll play a good/bad sound effect based on previous shell command exit code.

Something like:

  function boop() {
      local last="$?"
      if [[ "$last" == '0' ]]; then
          sfx good
      else
          sfx bad
      fi
      $(exit "$last")
  }

I'd then do:

  $ make -j; boop

  $ nmap <...>; boop

That way I can focus my attention elsewhere while waiting for stuff that'll take anywhere from 20s-2min without losing track of time.

Lately I've been experimenting with throwing in notify-send in there too, but find it a bit much to both get sound and visual feedback.

I remember I was screen sharing while troubleshooting something at a new job. I hadn't really set up my mac, and most everything was still defaults until I got a working build/deploy. One of the founding engineers said "You should turn bells off on your terminal. If [the CTO] sees that, he will give you so much shit." I should have taken that weird but ultimately innocent interaction as a sign that I was walking into an absolutely insane environment.

It's a tangent, but the bell character is a left over from how people used to do what you are asking for. Your question just reminded me of that strange conversation and harsh reaction.

I use a plugin called Grep Console in my JetBrains Rider IDE. It lets you auto highlight, color, or play a sound when certain regular expressions are found in the log output. So I set it to play an 8-bit sounding “thump” sound whenever it sees an [ERR] in the log output to hear any handled, but logged, errors. I also set up other sounds for specific things I’m looking for so I know when they’ve occurred (sirens, ahooga horns, sproings). It’s a great help, along with color coding, to find things in a long log file when verbose logging is turned on.

It sounds a lot like “auditory icons” as used in Emacspeak [0] and some other environments to improve accessibility for people with vision impairments.

Bill Buxton [1] seems to have a good treatment of the subject but i don’t know what’s autoritative

[0] https://tvraman.github.io/emacspeak/manual/Auditory-Icons.ht...

[1] https://www.billbuxton.com/AudioUI06icons.pdf

If you're on a Mac, your terminal has `say` built in. Lots of Mac users don't know about it but I use `say` a lot.

    $ bash long_build_script.sh; say job done

    $ sleep 1; say job done

Yes, here are some of my scripts:

gcc hello_world.c ; beep -f MICROWAVE_DING_FREQUENCY

gcc hello_world.c 2> /dev/snd

./hello_world xargs -I {} curl -X POST "https://api.openai.com/v1/audio/speech" \ -H "Authorization: Bearer sk-Ajs7aNsa8dJa5dr8jS4xManJ6V9xIjk" \ -H "Content-Type: application/json" \ -d '{"model": "tts-1", "text": {},"voice: "echo"}' > /dev/snd

It really is interesting that we generally don't utilize sound as much in development as our other senses. One reason many of us don't might be that we listen to music as a way to focus while coding?

Sort of related, but I was monkeying around on MonkeyType the other day and turned on the 'pentatonic scale' key sound effect... and it seems to help me be more consistent with my typing? It's quite interesting and rather unexpected. (If anyone knows how I could recreate that sound effect globally, I'd appreciate it!)

I use short beep in all my inotify/rsync scripts to make sure that local file I just saved was finished uploading to server so I can refresh the browser.

Another one is espeak that says "keyboard" when my keyboard get disconnected (usually due to me soldering stuff which then kills my keystroke monitoring keylogger which then I need to manually restart because it runs as root)

On Upwork page a custom extension keeps continuously beeping when new message appears in chat.

At 17:00 espeak says "17:00" to remind me it is time to make a soup.

There was once a VSCode extension that would make typewriter sounds as you typed, including a nice "ping" when you hit enter. A quick search shows a few extensions like this, but I tried installing one and no joy. But it was really nice to get a little audible feedback.

I do think this is a great idea. I notice that I get super engaged with video games in part because the constant noise meshes well with ADHD, and so I'd love to see a VSCode extension of some sort that can do this.

I have Xcode set up to play a sound effect when a build or a test run finishes successfully, and a different sound effect (the Metal Gear alert) when it fails.

I've used the same sound effects for decades now.

In Windows, open the Sound control panel page (type Alt-R then enter mmsys.cpl is the easiest way to get there) and on the sounds page there's a list you can scroll to see all the program events you can define sounds for.

I use Visual Studio and play a Homer Simpson "Doh!" clip for build failed and a Fred Flintstone "Yabba dabba doo!" clip for build succeeded.

I would really really like a VSCode extension that went "bing" when a build finishes. I think that would seriously boost my productivity.

Great starting point for a fun little project. Let us know how it goes :)

Tragically, I'm deep in the weeds on a fun BIG project at the moment. :-P

https://rerdavies.github.io/pipedal/

I have a completely local dev environment for a cloud based project. It requires me to stand up a few things so I can mock resources like Google Cloud. It can sometimes take a bit to populate all the customer config, depending on the machine I’m using anywhere from 5 sec to 45 sec. I think I’m using systemd to pop a notification at the end of a lengthy start up script For everything.

This sounds like hell.

It might be a brainhack positive reinforcement type thing, like "tests passed! Ding!" but for actual functional use ("File passed linter! Ding!" every few seconds) sounds like overstimulation fodder.

I already get annoyed at my machine when it's trying to correct what I'm writing faster than I can write it incorrectly. Let me get the rough draft out first.

I listen to the sounds of my code loading from my cassette tape drive. And my modem makes sounds too, when I'm doing stuff in the cloud.

In the previous startup I worked at, we set up a PR action that played a celebration thingy after every PR merge. We used https://github.com/leokster/dingdong_sonos to play on the Sonos speakers. Fun little gimmick but not really as a usecase like colors for linting etc.

Yes; my build script plays one sound on success, another when lint fails, and a third when anything else fails. It’s on a watch loop so it runs whenever I save.

I use TDD, so I’m running the build every few minutes. The build (including tests) only takes half a second, so I can hit save, hear a sound, and continue programming without looking at the output. It’s surprisingly nice.

I buzz in ahk on timeout paths (e.g. dialog failed to show), also signal the end of lora training (half an hour+). Tried to voice over tsc -w errors, but that got old quickly.

I work in automation so sending an IM in case something’s wrong (or finished) is not a rare thing. May count as a sound too. I also shoot videos of everything a visual script does for debug (xvfb, ffmpeg).

I worked for a company where the main workflow was to download an entire postgres dump at the start of the day and work off that. It took 25 min. I aliased our download command to play run a profane version of `say "beep beep"` after it finished. Then one time it spoke up during our stand up and everyone heard. It got more polite thereafter.

I don’t, but I can imagine someone using them for events that may take a while (e.g. build ended, tests ended, deploy ended), or particularly if the event is a failure they have to respond to.

Xcode at least used to have sounds for “build failed” and “build succeeded”, and IntelliJ gives you notifications for build and test failures when the app isn’t focused.

Hook up different kinds of alerts/notifications to office intercom and announce outages and pages! Gives the feeling of a real sense of urgency and danger! :-) Sev1 alerts, DDOS attacks etc. You can do this for positive things too – like a e-commerce product launch going out of stock in record time, or hitting a sales target etc.

in the late 90s i used a script someone made that would trigger callbacks on syslog patterns. there's different types of icmp traffic; i had iptables log the type that the ping command uses, and i played a submarine ping for each that my gateway received. i'm on the east coast usa, and i remember that i would get barraged with pings overnight, around 4am, as my ssh port got hammered simultaneously.

its 25 years later and the thought of having a single discoverable element on the net scares me.

i would really like an app that can create ambient music with composition: small songs that can overlay with harmony; if my network is running hot the baseline ramps up. if i have emails waiting, little tweets from a treble track that are fleeting but line up with the beat. there's so many ways i could use that soundtrack. plug it into the ide, errors in the buffer, subtle cues.

I do some personal work in MacOS 9 on a MacBook Pismo and use the standard Platinum sounds at a low sound level. I personally find the little click and chirp soundtrack quite useful as audio feedback. Though if I were to do this in the office, for the sake of my personal safety, I think I would wear headphones!

I've used it in anger on a project with an unreasonable start time in its test suite. Put an alert sound on VS when breakpoints were reached let me start a test with debugger attached, and then go do something else for the time it would take to start, but not forget what I had been originally doing.

I forget if this is a setting or on by default, but VScode will play a sound when a task is finished running, and it's different based on whether the task succeeded or failed. I use this so that I can leave long running jobs (usually testcases) running and not have to keep checking on the status.

I suppress all the sound effect alerts Windows makes. They're not helpful, just annoying.

But when debugging real time software, where instrumenting the code breaks it, I would have the code run an instruction that toggles the speaker state. By the tone it makes, I can infer what's happening.

https://github.com/daved/shound

Configurable to play a sound for any command you set (including not found). I've been using this or similar for many years and find the terminal to feel empty without it.

Decades ago I tweaked a toy raytracer I was messing with to make a click for every screen pixel traced. It made zero practical sense, but the result was way cool nonetheless. Added another dimension to the rendering process and made it feel more tangible, if you will.

Only a little bit. I have VS Code configured to emit a small sound when a terminal command fails, or when a debugging breakpoint is hit. I also used to add `; say "tests are done"` to my test command so I could go to another screen and know when my tests finished.

I'm moderately interested in audio feedback indicating performance behaviour. Maybe memory allocation or syscalls. Page faults. Something to play during unit tests or similar and give some indication of things going wrong. Not interested enough to implement it yet.

HELL YES!

I actually did set my shell to spawn a background task to play the vine boom whenever I entered an invalid command.

Something like

    command_not_found() {
      pw-play /opt/boom.opus &
    }

And it actually improved my command accuracy by a lot. And it was super fun.

A small sound effect I used once. At my last job, I queued a beep in my terminal at the end of the company-needed opening script that took 3 minutes so that I could look away and know when it is ready. (Useless to say that I almost never closed the console.)

One rather fabulous example I encountered had speakers rigged up to the wallboard that displayed pipeline info, and when someone broke the build, a clip of "Father Jack" from Father Ted profusely swearing was broadcast out across the dev room.

For long running scripts, I like to finish them With something like `say "wake up lazy bastard`. My previous employer has a wiki full of procedure containing this kind of easter egg. (I knew the founders and it made them laugh, so no issue there)

Unshielded embedded systems generate RF noise that can be received on AM/FM radios. Some devs figured out which processes generated which noises and could determine what the system was doing, or if a loop was taking too long just by listening.

Matlab plays a sound on error by default (on some systems through the internal speaker, bypassing volume controls) and I always found it irritating.

The only use case I see for them is something running in the background that takes a while and might get interrupted.

I integrated this handy squeaky door sound effect for when I open my laptop based on its ambient light sensor [1]

[1]https://youtu.be/pzJwDs6KRXA?feature=shared

Come to think of it, Windows 95, XP, etc. had lots of sounds built in. ICQ played a typewriter sound with every single keystroke. It was a bit annoying, but if I listen to those sounds now it definitely brings back a strong sense of nostalgia.

At one point I had my partner scream "breakpoint" and recorded it, it then played from my ide whenever a breakpoint was hit so I would swap back to that workspace and continue working.

But it got extremely annoying within a few days as you could imagine

When some repetitive task (rebuilding a program, running tests, …) tend to last more than 30 seconds, I like to make it beep when it’s done so I can do something else and not get carried away and loose some precious time on my #1 priority goal.

Yes, if I have a long running script in Jupyter I run a cell right underneath containing

!say “done”

And turn my speakers up.

No. I also don't listen to music.

I do, however, use colors, and the GUI over CLI, whenever possible.

Programmer preferences really differ, don't they... I listen to music, don't use colors, and prefer CLIs over GUIs. I also like my BEL to beep.

Yes! I used it a lot with CDK as all the process was usually quite long so I switched to doing other things and a nice sound would tell me the synthesis went fine whereas a "broken glass" sound would mean I need to do better.

When I was a kid learning pascal, I used beep() debugging (similar to printf debugging)

I’ve set my shell to discreetly play the sound of a mouse button click upon completion of any command that ran for longer than 20 seconds. That choice of sound has the convenient effect that no one else seems to consciously notice it.

Been thinking about this. Do you have a snippet you can share?

ZSH plugin:

  _click_preexec() {
    _click_start_seconds=${_click_start_seconds:-$SECONDS}
  }

  _click_precmd() {
    [[ $+_click_start_seconds ]] || return

    if (( SECONDS - _click_start_seconds >= 20 )); then
      pw-play 'mouse_click.wav' &!
    fi

    unset _click_start_seconds
  }

  preexec_functions+=(_click_preexec)
  precmd_functions+=(_click_precmd)

Mouse click sound: https://freesound.org/s/223445

I made a small CLI pomodoro tool that both locks the screen and emits a chime sound when the time limit has been reached.

https://github.com/Melvillian/pom-cli

For very long local builds, like a full bitbake, I do `&& bell` so I know when to tab back to my build terminal.

i.e. `bitbake bsp-vendor-full-image || beep && beep` so I get a sound when things finish, whether it failed or succeeded.

I added an alarm to my prompt so it happens every time a command finishes. I only use a visual bell, which propagates through tmux and my window manager. So basically, if I'm focused elsewhere when a command finishes, I have a nice indicator reminding me to go back.

Sometimes I'll add a chime to a long running build, eg `make || aplay fail.wav`

I sometimes use say to alert me when a long running script completes. https://ss64.com/mac/say.html

> doSomething && say “Finished!”

I used them when running some tasks. There's a shortcut for it in my dotfiles.

Years ago we decided on gradles earlier versions. I added a sound effect to my machine for when it finished. I might have used a video game computer sound so that it sounded real and not super annoying to anyone nearby.

When I was writing electronic trading systems, I experimented with audio logging for different types of fills / cancellations / other trading events. It was useful, but somewhat annoying. I disabled it later.

I used to have an intellij plugin that would make a sound when there was a regix match in the terminal. It was extremely useful, I had it set to make a sound when a build was complete, or there was a compilation error.

I do

`stupidlylongrunningcommand | say 'stupdily long running command complete'` a lot.

My dad used to work long hours at a startup where the build-times were non-trivial. He setup his build to echo infinite ^G characters (i.e. the terminal bell) when it finished and would nap while it was building.

I've set up https://github.com/whleucka/reverb.nvim after that and finding it really fun

Here's my very simple solution

Add this to your ~/.zshrc or ~/.bashrc

alias alertme='printf \\a; sleep 0.1; printf \\a; sleep 0.1; printf \\a; sleep 0.1; printf \\a; sleep 0.1; printf \\a'

I add this after longish tasks - eg:

python longtest.py; alertme

seeddb; alertme

I suppose the Michael Winslow method doesn't count? (https://www.youtube.com/watch?v=robOb5F3sOk)

Visual studio plays a >donk< on test or build failure and a ding on success. I have a habit of switching away to another project or hacker news while tests run, so this is extremely useful for me.

A friend told that at the trading company he worked at, traders set up distinct sounds for alerts.

I was hoping someone with a more direct source would comment in the thread but a quick Cmd-F doesn’t turn up anything!

I have both sounds and visual for process success or failure from the command line https://github.com/shapr/bloohm

It kinda works on a keyboard also

https://mclare.blog/posts/making-a-bloom-filter-keyboard/

Other than 3 hours where I modified git push to play "Push It" by Salt-N-Pepa before it got annoying, nope.

My first thought was some kind of 16-bit sound when you open and complete different brackets, perhaps a different sound for each depth, but I imagine that would become annoying pretty quickly!

I've set my Slack notifications to the "Hummus" sound instead because it's a lot less stressful and funny. Yes it's on your Slack too. Join me in chickpea silliness.

Example of the sound: https://www.youtube.com/watch?v=agShdo4yxxA&t=36s

Continuous testing tools would make good use of audio. It's been a minute since I have been in need of such a tool, but I could appreciate differentiating sounds for passed/failed.

I once had a very boring job with long compile times. I played a sound at the end of the build script, because otherwise I would just start goofing off and not doing anything.

(I quit shortly after that.)

Yes. I’ve modified maven so that it says “Success” or “Error” (with the command `say` of macOS). It’s very useful when you have a build of 30-50s that you execute dozens of times a day.

Not in dev environment but syadmin one, we used play sound on the machine which was hosting the nagios monitoring dashboard on a TV screen.

Better to have one sound than 5 individual phones alarms.

When making my own editor I found one place where I wanted to have sound: When searching, and the search has reached the end - I added an auidble beep as well as a shaking effect.

In Olden Days (but recently enough it was retro) we borrowed a receipt printer from the front desk and printed the motd and jira tickets and fortune statements at random times

I sometimes do (on my mac)

`some_long_running_script; say "done with the script"`

and it'll say the line when it's done, whether there's an error or whatever. so I know to check.

Definitely need to add a womp womp on a compile error

I feel like I would get PTSD eventually. The slack new message sound triggers my anxiety, I can only imagine what a compiler error sound would do to me :D

personally, as mentioned by others, a sound alert can be handy as an idea when a long-running background task finishes. this is especially pertinent for those on ssh sessions to another machine.

my spin for the workaround used to be echoing the "bell" symbol (07) in ASCII after the command finishes. but it would not respect the audio device i use while i tried it. definitely a good usecase for ricing your bash/zsh.

I use the say command on MacOS for a few things.

That command is a kinda fun. One time I had it read out to the lyrics to "Fitter Happier" using the Fred voice.

No - in fact I habitually leave my speaker muted, to prevent programs like Slack from distracting (and likely irritating) my co-workers in the office.

MacOs ships with the `say` command and once in awhile I'll do something like `longRunningProcess ; say its done`, but not beyond that.

I sometimes use sound to notify me when long running tasks finish. On macOS you can do this by doing "long_command; say done;"

Yes, if it's frequent it becomes annoying.

If it's infrequent you forget what it's for.

I blare music when I code too, so that takes precedence.

I configured my Xcode behaviors to play a sound when a build is completed or when the test fails/passes.

I've long wanted to explore this. There are two ways one can go about it:

- Airliner cockpits use certain audio signals deliberately and sparingly, to draw attention to important events.

- Some systems naturally (or artificially) emit sound as a side effect of what they do, and this sound, while not signaling anything specific, is part of what allows the operator to build mechanical sympathy for the system.

I think these two are completely different ways to use sound, but I imagine both could be viable.

Yes, the system beep, although that just makes the terminal flash on my setup :)

for very long builds, I'll simply add `; say "build done"`

On macOS, when I run a long script I add at the end:

    say done

I use `ping -a` so that when the host comes up, my terminal will beep.

What about smells? Scent is a powerful tool for recalling memories.

I make them myself

I have. You can assign sounds to stuff in IDEs, which I had some fun with in the early days of Visual C++.

I was the tech lead on a project at a Big-6 consulting firm, so my friend and I set the team's machines up to point to wave files on the network for basic compilation events. Success, warning, error. And the Windows startup sound.

This allowed me to change any of these sounds at any time, unbeknownst to the team. At some point, I changed the "build failed" sound to my own voice saying "That's crap!" It was amusing to hear this randomly coming out of this cube or that... especially my own, when I had a build fail and said "That's crap" right before my computer said it in the exact same intonation.

Yeah... easily amused in the days of "Compaq Business Audio!"

I find default calendar notifications useless. They pop-up 15 minutes before the meeting so they get dismissed, out of site, out of mind. With an integration of Keyboard Maestro, iCalbuddy, Stream Deck and modified shell script I show the upcoming meeting on a Stream Deck key.

Stream deck key shows time of next meeting, how long until that is, with background colors changing as it approaches, and how many meetings remain for the day.

For the sound effect portion, at 1 - 2 minutes prior and at the meeting time, a sound effect is played giving me the heads up that a meeting is starting. Also at 1-2 minutes prior to meeting starting, the Sonos speaker in the office announces the meeting subject.

I don't hate my coworkers that much.

Yes, we do... when the system reboots.

Everyone with a mechanical keyboard

steve gibson of grc apparently uses sound as a second input channel to handle various tasks. as i recall he made an app decades ago called wizmo that allows you to script sounds, and as listeners probably recall, yabba-dabba-doo is one such audio channel input to let him know someone has made a purchase order on his website.

Many years ago I had a manager who set a sound on our monitoring system to make a noise every time we got an alert. It went off non-stop and everyone started yelling at him until he turned it off.

it would be hard to hear it over the roar of my mad typing on a mechnical keyboard

i change the default windows beep, does that count?

Sorry this is totally unrelated, but I don't know how to notice replies on HN, and missed a question from you 5 months ago, and HN won't let me reply to that old comment.

You asked what adlist was blocking assets on a site of yours, and I don't think it's an adlist, but a general rule against loading scripts from other domains. Here's what the log looks like: https://cdn.imgchest.com/files/w7pjcgqn387.png

    ping -a

what is wrong with the top comments in this thread? Fastest way to get me to find an alternative software is to have it start beeping and whistling at me.

From my perspective, this is unnecessary overhead.

Now that you mention it, OpenSCAD makes a sound when it's done rendering which I find very helpful. Sometimes it takes several minutes and I usually want to queue up a print right when it's done.

Yeah I sometimes say like BOOM or NIAAAOOOMM when I get things working

Absolutely fucking not. My computer should make no sound that I don't explicitly ask it to make.

Well if you've configured your environment to use an audible alert for some condition, haven't you explicitly asked it to make the sound?

Yes. My computer can't even make a sound even if it wants to (no speakers connected). My phone has the same settings -- all sounds off, the exception is for turn-by-turn nav if I'm in a dense area, otherwise I just follow the blue line.

yes

> blacklist pcspkr

Absolutely not

Reply on news.ycombinator.com