Avery Lee is the author of VirtualDub, a video processing tool, and of the Altirra Atari emulator; the site hosts both.
Commenters remember VirtualDub fondly, praising its direct-stream processing and use with the Deshaker plugin for video stabilization, and note its roots in the anime community.
As someone who reverse-engineers and has seen a lot of compiler-generated code as a result, I'm even more convinced than before that the whole "compilers are better at generating code" mantra is a myth. The only thing they're good at in practice is generating lots of code quickly; there are instances when the output of a compiler manages to impress me (Intel's is particularly good at that), but they're still quite isolated instances and the rest of the code continues to have this "compiler-generated" look to it, i.e. much could be improved.
It is certainly not hard to beat a compiler on speed or size (often both), and I believe that the only ones who can't are the ones who learnt Asm the stupid way that compilers generate code and not how the machine really works. E.g. it's commonly taught that x86 has 6 general-purpose registers (reserving eBP/eSP), but in reality eBP-based stack frames and the use of the stack is nothing more than a compiler-generated artificial construct. Even eSP can be used for something else if you really need one more register[1]!
Compilers follow the rules of their source language and impose strict, often unnecessary conventions on their output. Asm follows the rules of the machine, which are far richer and more expressive than the abstracted simplicity of any HLL. That being said, they have improved significantly over the years - the days when compilers would push/pop every register on entry/exit to a function regardless of whether it was used (or…
These are software I love to use. I don't assume they're the best, and if you have any similar suggestions I'd love to hear them. There's a heavy Windows OS slant to this list.
SunVox - Sequencer and tracker. The user interface is a big evolution from more traditional trackers because of how visual it is. This reduces the barrier to getting started, but it also make using the program simply more enjoyable.
http://www.warmplace.ru/soft/sunvox/
VirtualDub - Video processing. This is my go-to tool for simple video editing. It remains the quickest and easiest way I know of to make animated GIFs from video.
http://www.virtualdub.org/
HxD - Hex editor. Handles GB scale files very well.
https://mh-nexus.de/en/hxd/
Foxit Reader - PDF reader. There's some conflict in the past with bundling adware installers with the software, I hope that practice is long gone. This is the most full feature Adobe Reader alternative I know of.
https://www.foxitsoftware.com/
Daemon Tools Lite - Virtual disc drive manager. Unfortunately limits to 4 drives.
https://www.daemon-tools.cc/products/dtLite
Space Sniffer - Disc space visualization. The clean look and intuitive visual interface is why I prefer this over WinDirStat.
http://www.uderzo.it/main_products/space_sniffer/index.html
Other software I use, but which I expect is already well known: 7-Zip, Audacity, Blender, GIMP, ImgBurn, Inkscape, IntelliJ IDEA, Kodi, Libre Office, Notepad++, PuTTY, Unreal Engine 4, VLC
(This is a reply to this whole sub-thread, not just this comment.)
Most well-known approaches to cross-platform mobile app development have left me dissatisfied. The root problem is the required bridging overhead between the cross-platform code and the platform's native runtime (the ObjC runtime on iOS; Dalvik/ART on Android). Using C/C++ for the cross-platform code is the lowest overhead approach on iOS, but it's suboptimal on Android.
So why does this matter in practice? A few reasons:
Multiple coexisting memory management systems: In general, my understanding is that a garbage collector behaves best when all memory, or very near all of it, is under the collector's control. My fuzzy intuition is that the least optimal situation is two coexisting garbage collectors, e.g. Xamarin.Android or a JavaScript engine other than Rhino on Android. But mixing a garbage collector with reference counting or manual memory management, such as with native code on Android or RoboVM or Xamarin.iOS, also seems to be suboptimal. If a significant amount of memory is allocated outside the scope of the GC, then the GC doesn't have as much information with which to intelligently decide when and how much to collect. Also, in hybrid systems like the ones being discussed here, objects under the GC's control sometimes have to be pinned so they can be accessed by the outside code; this interferes with copying or compacting collectors.
More…
There are some neat tricks you can do with the 2 stereo signals. Linear combinatios of L/R channels is the easiest, but doesn't work well with modern mixes where bass/snare/voice is centered and other instruments are rarely ever hard-panned (you can get really cool results on some older albums like Rubber Soul - there's a lot of hard panning going on there)
There are of cuorse more advanced techniques for isolation of centered tracks and vocals in particular see http://virtualdub.org/blog/pivot/entry.php?id=102 and http://dsp.stackexchange.com/questions/1499/how-to-extract-vocal-part-from-stereo-audio-signal
Atari shipped a final Rev C basic both in the ROMs for the XE computers and on cartridges for people that requested it.
There were several derivations. The original authors of Atari Basic produced BASIC XL and BASIC XE on cartridge, each with additional language features. There's also the really cool Altirra BASIC (see https://virtualdub.org/downloads/Altirra%20BASIC%20Reference%20Manual.pdf) which ships with the Altirra emulator as a tokenized-code compatible, but faster and more featureful, implementation. A version of that was included in the ROM for the new 576NUC+ all-in-one Atari-compatible.
It could be fun to compare with Action!--it's been known to compile a reasonably good 6502 assembly (considerably better than other compiled languages for that platform), https://en.wikipedia.org/wiki/Action!_(programming_language),
It has been released as open-source together with the binaries, https://atariwiki.org/wiki/Wiki.jsp?page=Action
You should be able to run these using an Atari 8-bit (XL/XE model) emulator, like Atari800, https://github.com/atari800/atari800/releases or Altirra, https://www.virtualdub.org/altirra.html