That said mixing DSP + UI is hard, and if you want to make the scripting user accessible it makes sense to keep them totally divorced.
970 karma · joined February 19, 2019
That said mixing DSP + UI is hard, and if you want to make the scripting user accessible it makes sense to keep them totally divorced.
If you want a really great approach to noise gating, a fixed threshold is fine but it works better when you apply it to the difference of two envelope followers - one with a short attack, long release (tracks input) and long attack, short release (tracks noise floor). Takes a bit to set it up, but it's a stupid simple way to get extremely effective gating and is easy to fine tune for your application. A lot of Voice Activity Detection (VAD) works this way; it's just a matter of tuning the coefficients and thresholds for your input.
Also useful reference for envelope following are the DAFX text [2], Will Pirkle's textbook on audio in C++ [3] and Zölzer's text [4]
[1] https://github.com/m-hilgendorf/rusty-compressor
[2] https://www.amazon.com/DAFX-Digital-Effects-Udo-Z%C3%B6lzer/...
[3] https://www.amazon.com/Designing-Audio-Effect-Plugins-C/dp/1...
[4] https://www.amazon.com/Digital-Audio-Signal-Processing-Z%C3%...
(pdfs can be found around the internet)
One cool thing about Drop (and some other cool stuff, like MaybeUninit) is that it makes doing things like allocating/freeing in place just like any other Rust code. There may be some unsafe involved, but the syntax is consistent. Whereas in C++ seeing placement new and manually called destructors can raise eyebrows.
[1] https://itanium-cxx-abi.github.io/cxx-abi/abi.html#vtable
I'm really glad MS is doing this. What needs to be a bit clearer to me is how they maintain ABI compatibility under the hood of MSVC for COM interfaces (which uses the vtable layout of an inherited class) and how that's compatible with MinGW/GCC stacks on Windows, mostly what can break it. I got stuck porting VST3 with multiple inheritance, and it was a headache trying to reverse engineer the appropriate struct layouts for COM implementations.
[1] https://github.com/retep998/winapi-rs/blob/0.3/src/macros.rs
[2] https://github.com/Connicpu/com-impl
[3] https://github.com/steinbergmedia/vst3sdk
[4] https://github.com/m-hilgendorf/cli-host (sorry for the messy code, it was a weekend of hacking away trying to host a VST3 in pure Rust)
Most of the time you don't need hundreds to thousands of data points to be reasonably confident, just a few dozen. I remember the example distinctly from my sophomore engineering stats course, I don't know why everyone else has forgotten it.
But keep in mind these companies are usually pretty small, a lot of sole-proprietors out there, and their revenue comes from new products/sales not maintaining projects. So there's logistical and incentive problems in deploying fixes quickly.
That software is a lot like vintage gear, there may be alternatives but they aren't the same, and that's the problem.
Is this an issue in practice? Like I get if I have an asset that meets inflation for a decade than I'll lose value through the taxation. But that would be a bad investment, wouldn't it?
>it's much less than that because of inflation
Why would you hold an investment for 55 years that isn't beating inflation?
That's because the OS developers have placed value on security over performance. Whooping cough is rare too, we still vaccinate against it.
If you want a classic example, bounds checking an array is important to avoid RCE and sandbox escape attempts. It can also have a hefty performance penalty, under some scenarios it trashes the branch predictor/instruction pipeline. But I'm glad that my browser isn't as fast as machine-ly possible when streaming video, because I'd prefer if there wasn't a risk of having my emails from various banks, stored passwords in the browser, etc from being collected and sent to a bad actor.
- Diminished: Minor Third + Minor Third
- Minor: Minor 3rd + Major Third
- Major: Major 3rd + Minor Third
- Augmented: Major Third + Major Third
With the intervals being between the tonic and third, third and fifth. So for your example, that would be A, C, Eb as a diminished triad.
What's the difference in theory and practice between UBI and changing the standard deduction/marginal rate? Like if we give out $6k a year to everyone through a $500 check, what is the difference in how that money is spent versus if we increased the standard deduction to where people would pay $6k less in taxes? (assuming that people are in fact paying at least $6k)
I get that this is partly an experiment to figure this out, but what does the current theory say?
Feature request: viewing the intervals on a keyboard/fretboard, with different colors/numbering for each scale degree.
Personally I don't care about app count, I'm just not a huge fan of when companies spin features off as products unless it makes total sense. I think it does in this case, it looks like a crossover of Messenger and Instagram that reminds me of Snapchat when it was just a sexting app.
Sidenote: how do you actually determine the spread for tax purposes when you can't sell the stock/it doesn't have a current price?
This solution pays me for my inconvenience. It doesn't prevent the inconvenience in the first place or from happening again.
I'd rather just ban assholery than create a steep asshole tax. It doesn't bother me that a few rich people will have to wait in traffic like everyone else (or better - stop traveling for cross-town meetings and take a phone call!).
Leave low altitude flight to emergency services.
Well and they sound completely different.
The UI differences don't come down to number of controls but the fact that most analog designs have a 1:1 relationship with the sound, every knob you turn has a very distinct impact on the sound and usually, applying that to any input generates more or less the same impact on the output. It's extremely intuitive to learn how changing a knob changes the sound.
FM is completely different, where altering simple things like the operator ratios and modulation index have massive changes on the sound and don't create the same effect on different sounds - it's naturally non-intuitive. Most FM wizards get there through tons of experimentation, not through established fundamentals.
Imagine playing a wind instrument and changing your embouchure alters the pitch of the differently depending on what note you finger. That's what programming an FM synth is like.
iPad synths are a dime a dozen these days. Lack of a physical interface is as big a problem on them as with larger synths. They are hardly tactile.
A corollary here is the success of wavetable synths compared to granular, additive, and FM in the softsynth space. Wavetables have the same subtractive model as traditional analogs, and incorporate many of the same features as semi-modular synths. But they are extremely versatile because of how their interface is intuitive even for first time users - it's stupid easy to change the sound, the only additional dimension is the wavetable but that's quick to pick up. Compared to say, granular synths which are possibly the most versatile paradigm, but whose controls are extremely divorced from the timbre of the sound you design.