678 karma · joined January 11, 2014
Once you think you grok it, you can pick a Lisp that's closest to what other tools and frameworks you're used to. For me, I never actually did anything in Lisp for production use, but learned a lot from playing with various flavors of it.
OBD has always been a small subset of what's happening on the CAN bus, or rather busses, nowadays. Some of the vendor specific things are necessarily unique, but a lot of it is deliberately obfuscated and undocumented because of various idiotic things.
There is truth to the electronic systems in a car having become orders of magnitude more complex than 20 years ago, but that in itself doesn't quite cover it.
Some problems arise without actual malicious intent because every itty bitty control module, of which there are nowadays several dozen in every car, is very likely outsourced by the OEMs, and the suppliers are as bad at following specs as the OEMs are at writing them. As market pressures have resulted in OEMs and suppliers having more adversarial relationships, both sides have become less willing to fix the other side's mistakes, and the customer is the one who takes the bath for it. The only ones winning in the automotive industry's OEM-supplier setup are wall-street, as they encourage the race to the bottom just to squeeze all possible short-term value out of the industry (and often taxpayer money) through an endless cycle of bankruptcies, spin-offs, and mergers.
Another problem is an acute lack of competency regarding computer systems design and implementations, as many OEMs are still stuck in processes meant for mechanical components, not electronics and software.
Even subtracting all the above idiocy, the industry as a whole sees no money in providing a servicable automobile. Unless the incentive changes because of consumer behaviour or regulation, nobody's going to put in the extra engineering work to improve the mechanic's "interface" as long as there's simply no profit in it.
You do have to get to grips with pattern matching and processes as objects being such core concepts, but I found that once I got it, it is wonderful.
The macOS kernel does have, in theory, the possibility to create a .kext that emulates a UVC USB device, so in theory all one had to do was to write a .kext that captures the DSLR/DSLM camera in kernel land, and brings up a virtual USB device that is then recognized by the standard UVC driver (eg. same as any other webcam).
Of course, that doesn't provide any camera settings controls, and the practical side of it is quite complicated, with sparse documentation and difficult development processes, it being a kext. Hence, nobody's done it, yet.
A lot of the current generation DSLRs do provide XGA, 1024x768 sized preview images when tethered, as, surprise surprise, that is the resolution of their viewfinder/screen. Older cameras, like the D800, only do 640x480, though IMO that is still a vastly superior image for video conferencing.
I've put together what I've found out so far at https://github.com/dognotdog/ptpwebcam/blob/master/CAMERAS.m...
Sony ILSM cameras seem to all do 1024x, DSLRs mostly do 640x480 unless they're from the last 2 or so generation of cameras. I have most complete information for Nikon, as they actually publish specs for the cameras PTP interfaces, unlike Canon or Sony, which have to be reverse engineered.
The short of it is that generally within the SIP (system integrity protection) domain, no 3rd party code is allowed to be loaded.
3rd party apps can generally be made to work by removing codesigning, but Apple's stuff is generally very intertwined with services not contained in the app-bundle, making this kind of surgery a lot more difficult. I have personally not been able to get this to work for FaceTime on 10.14 despite best efforts.
An interesting thing Sony seems to do here that others haven't is that they bypass the PTPCamera agent that normally comes on, presumably to directly drive the camera through their own lower level PTP library Lja_PTP_USB.dylib.
Disclaimer: I'm the author of https://ptpwebcam.org, which works much the same for Sony/Nikon/Canon cameras
And I don't see why that semantic singularity couldn't be local (or at leat private), instead of the current hodge-podge of "cloud" offerings trying to siphon as much data as they can – under the guise of improving the user experience – just to lock you into their version of the perfect walled garden.
Git is widest adopted, period (EDIT: because of how it blossomed out of linux dev, essentially). I was able to stick to bzr or fossil for a lot of things until github and gitlab basically became where open source work (and even corporate transitioned to some extent!) needed to happen, and the friction of using anything else is just too great at this point in time.
Which is a shame, really, as --fast-import/export is actually not a bad way to transition from one scm to another these days, and I'd personally welcome a little more active competition in the space to evolve beyond the current status quo.
GUI tools only help with that to some extent, too, and only the right ones.
Even though one-way pushes to github/gitlab via --fast-export / --fast-import are relatively painless, going the other way for contributions is still not easy because of rebase issues, etc, at least to my knowledge.
Scheduling, real-time characteristics, safety and watchdog mechanisms, and resource management pose hard engineering problems, and are often a very unique mix for each application, and again the Arduino libraries are not typically considerate of such concerns.
Add to that the usual pressures of keeping per-unit hardware costs low, to the tune of shaving a few cents off the BOM by choosing extremely constrained microcontrollers, and bending Arduino to fit those constraints becomes an unfavorable proposition.
The biggest benefit of Arduino as I see it is in reducing the barrier to entry for starting a hardware project because you can just wire software and hardware modules together for a proof-of-concept, but it doesn't do much for production.
It doesn't mean to unnecessarily expose implementation details, but I take it to be the other way around: implement things in a way that things work consistently without having to know the nuts and bolts.
The single biggest offender in both download and render time that I can do nothing about is youtube loading in over 400kb of Javascript for an embedded video, taking ages to first render, making everything feel glacially slow.
And getting through the beaurocracy, crossing the border by car was very much akin to https://youtu.be/JtEkUmYecnk?t=33
After that, finding out that the whole district your hotel was supposed to be in has been demolished just a few weeks prior isn't as surprising as one would think.
For one project I've spent considerable time trying to get the Azure IoT SDK going on a low-cost Wifi chipset, only to find out that it ended up not working after all the platform glue was in place because of inexplicable decisions from both the host APIs (no source code access, of course) and the Azure SDK, making most of the built-in functionality (eg https/MQTT/encryption) useless for Azure, resulting in not only code bloat, but also running out of heap memory with fantastic silent crashes.
After spending weeks on trying to fit everything into ROM in the first place. The end-result was ditching the SDK and re-implenting most of MQTT and websockets before the project was ultimately canned for other reasons.
A pi zero w, otoh, costs about $20 (with a reasonable SD card) vs $5 for something like the ESP32, and makes life easier with unlimited storage and open source platform code, but it is impossible to mass-produce anything for under about $120 retail cost due to the high price of the rpi alone, which is a real bummer in a competitive IoT market.
That seems to happen when refactorings are infrequent and random, vs. a well-groomed codebase. Of course the well-groomed codebase is a mythical creature.
The problem I see is that if refactoring isn't part of the culture, what tends to be built is a tower of cards that never gets the benefit of hindsight because with each subsequent change, the understanding of interactions decreases, and the fear of breaking something increases, leaving to very narrow cludgy changes that become impossible to maintain.
The added impetus of external schedules just exacerbates the issue until the whole codebase falls over, unless people come along who take on that risk and attempt live brain surgery.
I would've gone with libgphoto2, too, if the Mac didn't already have all this half-baked PTP infrastructure in place, and if libgphoto2 would've been easier to integrate into the CoreMediaIO pipeline.