Important! Again, I reiterate, because this is important!
I’ve seen this before, but I didn’t note it down. Now I am reminded of it again, so I will note it down. Git Town is a front-end built on top of Git designed to provide a more friendly workflow that is similar to the typcial workflow that most teams use with Git. Unlike Git-Flow, it does not impose a specific workflow upon people, but merely provides tools tha make it easier to do a certain workflow.
20181127/http://www.git-town.com/
The big problem with HTTP file downloading I’m having is that there are many times when I want to peek inside a large archive file or disk image file without downloading the whole file. I want to be able to just read the headers. But, with conventional HTTP tools and libraries, you must download a file whole before you can start processing on it. Particularly, this was being problematic for me since I was working with a Python tool for importing OVA templates into oVirt. The templates were hosted on an HTTP server, but the tool needed a local copy of the file so that it could read the TAR headers and determine the file contents via a standard Python library that worked with file descriptors. Alas, the Python HTTP modules did not allow for any such access pattern where you have a virtual file descriptor for a remote HTTP file where chunks are downloaded on-demand.
So, how to solve this problem? Of course via the traditional method
by this point in time. If you can’t rely on your user-space
applications natively providing some feature or function, see if you
can hack it into the operating system beneath. Thankfully, Linux FUSE
provides a modular, general purpose method to do exactly that. Of
course, patching the behavior of the kernel is ideal compared to
patching the behavior of libc, since a patched libc either
requires dynamic linking, the unlinked object code files, or the
source code so that you can link in your patched library.
So, yes, the solution!
So, yeah I’ve previously noted that there are 3.3 V motor driver ICs available on the modern market, but I have not yet found an actual module for purchase. I’ve got to search out such models.
20181125/DuckDuckGo 3.3 v logic motor driver
Ah, yes, there are some modules available from Pololu that can run off of 3.3 V logic.
20181125/https://forum.pololu.com/t/high-power-motor-drivers-for-3-3v-micros/8572
There a line of “high-power” motor drivers and another one of “simple” motor drivers. What makes the simple motor drivers “simple” is that they include lots of interface options to make it easy for inexperienced hobbyists to get something up and running quickly. Unfortunately, those interfaces increase the cost and complexity of the board, not to mention that they are redundant since you will only be using one of the many interfaces available. So, that being said, go with the “high-power” motor driver instead of the “simple” one as it is cheaper and more straight to the point.
20181130/https://www.pololu.com/product/2992
20181130/https://www.pololu.com/category/94/pololu-simple-motor-controllers
So, you’re wondering. How do you measure the air flow through a room? Well, I have a variety of ideas that I can list here.
Use a video camera to monitor the flow of dust through the air, or inject some kind of known smoke tracer that you cana optically analyze the flow using a video camera. Easiest intuitively but most complicated/expensive to implement.
Use at least two air pressure sensors in a room. Intuitively, this should work similar to measuring temperature gradients by using two temperature sensors in a room: the difference in reading and their locations tells you the air flow speed. Unfortunately, the main problem this suffers from is that the air pressure sensors likely aren’t precise enough to get any viable air flow data.
Okay, so let’s see what other ideas are out there on the Internet. In general, there aren’t really great options for this, so it seems. Real-time continuous air-flow monitoring seems elusive. There, there are lots of ways to design a point-in-time air flow measuring device, but not much in the way of running such a setup 24 hours a day.
Also, for measuring air pressure difference between rooms. There is no easy way to do this. Again, the air pressure sensors aren’t precise enough for this particular measurement. What you have to end up doing is building a tube to connect the air in the two rooms and adding special sensor instrumentation in between. Yeah, way too complicated unless it is absolutely necessary to regulate that quantity as may be the case in industrial and medical environments.
20181124/DuckDuckGo sensors measure air flow through a room
20181124/https://www.sensorsone.com/how-to-measure-delta-change-in-pressure/
So now I need to make some decisions on some base nice-to-have Molex PicoBlade connectors that I will solder directly onto the GPIO pin header. Here are my plans so far. Remember, with soldered pins, you can always add more easily, but removing existing ones is a bit tougher. So, the base ones installed on by default better be designed to be pretty reusable.
The main problem with soldering on connectors in advance is that if you solder on too many or connectors of the wrong type, you will have to remove those and re-solder. Also, although it sounds like a very good general idea to just have each pin independently accessible, this tends to be a real nuisance when it comes to connecting standard components on that require multiple pins. So, the idea is to make a good choice between soldering on multi-pin connectors, avoiding overwork in soldering, and keeping the system modular and reusable.
Okay, my idea. How about we approach it like this. You can start by soldering on large connectors that group together multiple GPIO pins. So, let’s start with the most demanding case: an EEPROM chip with a 32-bit address bus. Do we even have enough GPIO pins to support that? Well, let’s see.
32-pin connector for 32-bit address
8-pin connector for 8-bit data
4-pin connector for the flash chip control signals
Some interesting articles here. Wnat to make an open office plan work? You simply need to think “library rules.” Also, you have to remember that the sole motivation for doing so is cost-cutting and no other.
20181121/https://m.signalvnoise.com/library-rules-how-to-make-an-open-office-plan-work-f9f6d69a2d4c
Real-time collaborative chat software at work? In general, this author’s experience and understanding is that such software generally doesn’t work as a #1 go-to tool, but it does have its uses where it works better than the alternatives. Also, there is a very long list of weaknesses with improper use of real-time chat software.
20181121/https://m.signalvnoise.com/is-group-chat-making-you-sweat-744659addf7d
Wow, this is interesting. So, here’s a different opinion and experience about Golang’s error handling model. The main argument against not providing an exception-throwing model? Without an exception-throwing model, you rely on third-party library code obeying proper errror messaging conventions… which in practice, it doesn’t. Not unless you limit your choice of third-party libraries to such an extremely small subset that… well, you’d talking more of a curated core of libraries rather than everything were that the case. And of course you want everything so that you maximize the possibility of finding existing code for your application and minimize the amount of code that you have to write.
20181121/https://opencredo.com/why-i-dont-like-error-handling-in-go/
Okay, some notes on emulators and virtual machine options. First of all, QEMU is indeed a pretty good all-around choice if you want to both virtualize and emulate modern computer architectures where the binary software being executed is predominantly compiled from C/C++. It’s especially good for operating systems designed on modern Intel x86, x86-64, PowerPC, SPARC32, SPARC64, MIPS, ARM, and RISC-V architectures, just to name a few.
20181121/https://en.wikipedia.org/wiki/QEMU
So, you’re wondering about Compact Disc Digital Audio access under virtualization? How do you pack a virtual disc image to include this data? Is this feature even supported? If so, what virtualization solutions support it? This is a must-have feature for virtualizing some 1990s era game software under modern computer hardware.
Unfortunately, the best I can say for this is that virtual machine solutions in general don’t provide support for this. The main support for optical discs that they provide is for data optical discs. The primary and most common example of such data discs that are used is exclusively for booting an operating system installation CD.
Important!
So you’re wondering about Vulkan API support for progrmaming parallel compute code? Well, yes, indeed Vulkan can be used to program parallel compute code. But, it goes further than that. Matter of fact, OpenCL’s long-term plans are to be merged into Vulkan. So, if you want to program for the future, then try programming your GPGPU compute code against Vulkan API today. But, no worries. If your GPGPU code is small, simple, and easy to write, then it is also correspondingly simple to rewrite too. Not to mention, it appears that OpenCL will still be around for a long while, and maybe Vulkan API may have direct backwards compatible support for OpenCL too, eventually.
20181121/https://en.wikipedia.org/wiki/Vulkan_(API)
20181121/https://en.wikipedia.org/wiki/OpenCL
20181121/https://www.pcper.com/reviews/General-Tech/Breaking-OpenCL-Merging-Roadmap-Vulkan
Now, this is interesting. One of Microsoft’s newer Microsoft Office terms and conditions states this at the beginning. If you are using a enterprise volume licensed version, you do not need to read this license, as the volume license applies to you. Otherwise, if you are using an individual license, then these license terms apply to you.
20181121/https://support.office.com/legal?llcc=en-us&aid=Office_Mac_Use_Terms_2018_en-us.htm