Agreed 100%. I reached voting age in 2008 and I was one of those “both sides suck” idealistic young voters who voted third party. I did again in 2012 and again in 2016 thinking “Hillary’s already got this one, I can protest vote”. Nope, we ended up with Trump. Ever since that I will only vote blue no matter who, at least as long as the Democrats are the only viable party with some sense of normalcy. Third parties are completely unviable in the US election system. We need ranked choice for a third party vote to not be a throwaway vote. Until that happens, we can’t afford to pick “the best choice”, we have to pick “the best choice that actually has a chance”. Even if it’s not really the best choice. Very happy to have gone out and voted early last week. We need the blue wave. Once the Republican party is thoroughly stomped into the ground and made completely unviable can we focus on a truly liberal third party, but honestly we probably have a better chance of slowly moving the Dems left than we do a third party taking over. It may not happen in my lifespan but I’d rather see progress than regression.

APIs can be complex too. Look at how much stuff the Win32 API provides from all the kernel calls, defined data structures/types, libraries, etc. I would venture a guess that if you documented the Win32 API including all the needed system libraries to make something like Wine, it would also be 850 pages long. The fact remains that a documented prototype for a software implementation is free to reimplement but a documented prototype for a hardware implementation requires a license. This makes no sense from a fairness perspective. I’m fine with ARM not giving away their fully developed IP cores which are actual implementations of the ARM instruction set, but locking third parties from making their own compatible designs without a license is horribly anticompetitive. I wish standards organizations still had power. Letting corporations own de-facto “standards” is awful for everyone.

In the mobile Linux scene, Qualcomm chips are some of the best supported ones. I don’t love everything Qualcomm does, but the Snapdragon 845 makes for a great Linux phone and has open source drivers for most of the stack (little thanks to Qualcomm themselves).

RISC V is just an open standard set of instructions and their encodings. It is not expected nor required for implementations of RISC V to be open sourced, but if they do make a RISC V chip they don’t have to pay anyone to have that privilege and the chip will be compatible with other RISC V chips because it is an open and standardized instruction set. That’s the point. Qualcomm pays ARM to make their own chip designs that implement the ARM instruction set, they aren’t paying for off the shelf ARM designs like most ARM chip companies do.

Hopefully Qualcomm takes the hint and takes this opportunity to develop a high performance RISC V core. Don’t just give the extortionists more money, break free and use an open standard. Instruction sets shouldn’t even require licensing to begin with if APIs aren’t copyrightable. Why is it OK to make your own implentation of any software API (see Oracle vs. Google on the Java API, Wine implementing the Windows API, etc) but not OK to do the same thing with an instruction set (which is just a hardware API). Why is writing an ARM or x86 emulator fine but not making your own chip? Why are FPGA emulator systems legal if instruction sets are protected? It makes no sense.

The other acceptable outcome here is a Qualcomm vs. ARM lawsuit that sets a precedence that instruction sets are not protected. If they want to copyright their own cores and sell the core design fine, but Qualcomm is making their own in house designs here.

Leave it on, but turn off the monitor. I have it set up as a GitLab runner for some projects and also want to be able to SSH/SFTP in to access files, run updates, etc.

If you read the article, it is indeed full Linux because the 4004 is running a MIPS emulator that provides the necessary memory management features. Pretty much all of the “run Linux on some old chip incapable of running Linux” projects achieve it via emulating a more featured architecture that Linux supports, not by somehow compiling Linux to natively run on a 4 bit, MMU-less architecture.

I got a NexiGo portable gaming monitor that I’m pretty happy with. It is a 16 inch 2560x1600 display, 144Hz, and supports FreeSync. I got a bidirectional DisplayPort to USB C cable so that I could use it with my desktop for LAN parties and it’s great. It has a built in flip-out kickstand, a folding magnetic cover, OK built in speakers (good enough to game with anyways), and can be powered via a second USB C port with an A to C cable. On a device that supports USB C video output like a laptop or Steam Deck it can run off a single cable but I mostly wanted it for my desktop.

When it first came out it had double steak, when it became a permanent item it was made smaller.

Some of my favorites:

• Chicken flatbread melt (like a taco but with a fluffy flatbread instead of a tortilla)
• Beefy 5 layer burrito
• Cantina Chicken Quesadilla
• Breakfast Crunchwrap (preferably steak)

Open source NVIDIA drivers (NVK, nouveau, nova) finally being usable for gaming.

Linux phones, postmarketOS

RISC-V CPUs becoming more and more viable

Linux on phones and tablets is a thing. Typing from my Xiaomi Pad 5 Pro running postmarketOS and LibreWolf.

Hot dogs

Freddy’s fry sauce, barbecue sauce, teriyaki sauce, honey mustard, cocktail sauce, malt vinegar, cheese sauce

Pretty much all ext4 except for a few Windows installs on NTFS.

I wrote a program to do just that

https://gitlab.com/CalcProgrammer1/TouchpadEmulator

Ugh, I got a fair return from buying to AMD right before Ryzen came out. I sold some of it and bought multiple different chip companies so now I have some AMD, some Intel, some NVDA. Oh well, it’s not a huge amount but still sucks. I hope they can come back if only because AMD needs competition to keep them from becoming the evil that old Intel was. I was hoping Intel would also be a viable third GPU competitor, I like my Arc A770 for the price and I’m hoping they don’t kill off the GPU division.

I’m not sure about FF specifically, but 99% of the time you’re connecting a microcontroller to a PC you’re doing so over a serial port (UART) of some sort. It may be a physical COM port or it may be a USB to serial adapter or even a purely virtual serial port over a USB connection, but the methodology is all the same. Unless you are running a serial terminal on that port (as in, a commandline on your PC served on the given /dev/ttyX interface, not a terminal emulator letting you read/write from the port), the microcontroller can’t just run scripts on the PC. Instead, you will want to write a script/program that opens the port and waits for a command to be sent from the microcontroller, then that listener script can execute whatever functionality you require. Note that only one application can have the port active at a time, so if your listener is a separate program from your event handler, you will have to close the port on the listener before running the handler, then reopen the port on the listener once the handler is done so it can start listening for the next event. Better to just make it all one program that is always running on the PC and does both listening for events and handling them so there’s only one program that needs access to the serial port.

I can’t disagree with you there.

Should have not trusted a third party to install proprietary code into the kernel. It’s not a Windows issue directly, they have a Linux version too, but anything that allows third parties to put proprietary code into your kernel and automatically update it without your approval is untrustworthy.