Location - Phoenix.
Remote is acceptable.
I could consider relocating for the right job.
Technologies: C, C++, Rust, Python, Lua, C#, shell, heavy embedded Linux experience, wrote an init system in C when I was a teenager.
I can say that I'm a very good firmware engineer with a lot of experience tinkering with Linux and know most of the C language by heart. Currently doing contract work but looking for a more permanent position.
I have a lot of experience in audio/video, access control, extensive multithreading, and low-level networking (BSD sockets)
I am delighted to inform CrowdStrike that they have just done additional, extensive, damage to their brand, and will no doubt have just emboldened those who were tempted to sue them.
Your unethical behavior and abuse of the DMCA will be used to punish you.
If you succeed in getting ClownStrike taken down, you will be hated even more.
Have fun annihilating your brand, reputation, and customer/industry trust and goodwill.
They will not fix this. Indeed, regulation is required, but meaningful change requires a functioning, coherent government with institutions that are not fully enclosed in regulatory capture.
The United States is falling apart, and it is no longer capable of solving its own problems. Now, inertia keeps legacy systems functioning, until fascism and/or balkanization a-la USSR takes over.
Write your own. Wrote one fairly recently in good-ole-sepples that uses UNIX domain sockets and pushes around half a gigabyte a second on weak ARM hardware. Domain sockets are great. Shared memory is even better. If you need a portable solution between processes, not threads, I recommend domain sockets and a simple binary protocol for high throughput.
Rust apparently wants to reverse its warning logic and instead of banning unsafe{} inside unsafe fn(), they want to require it and make it a hard error.
Sometimes, I think about what I really want. What I want most in the universe, for myself.
There's plenty I want for everyone else. I seldom let myself think about what would be good for me lately.
Sometimes, like tonight, I do know what I want for myself.
It's impossible, but it's my greatest desire for my life.
I want to be "uplifted". I want my brain capacity to be expanded by orders of magnitude. I want to understand, I want to comprehend, I want to see it all and fully understand the shape and implications of all things in my sight. I want to be more than a human mind. I want to be far, far wiser. It's not power I want. It's knowledge. It's understanding.
Watch all the funding dry up and the researcher get framed for some random, stupid crime, with just enough prison time to make sure he won't see the inside of a lab again before he's too senile to use it or dead.
Could also be a slip in the tub etc.
There's a lot of money in suffering, and if you think there aren't people sick enough out there to do real horrible shit to protect that income stream, you're kidding yourself.
How do you think this fucked up civilization was twisted into the giant pulsating tumor it currently is?
Finally, a software fad that I actually want to support! About time I get one!
SQLite is more than good enough for an awful lot of things. Most of the time that I do see software using MariaDB etc, I think to myself "they didn't need a server model for this, SQLite would have been fine".
My personal rule of thumb is that if someone is making gurglings about X possibly happening in the future, I will probably take some steps to make it easier if X does indeed happen in the future. If it's something I think is pretty much universal, I don't bother. "What if X" is not good enough, you also need "they were talking about/speculating about X". This rule tends to serve me well.
On every PC I have, the Ukraine "live feed" video at the top manages to start playing on its own as soon as I'm not looking. It doesn't do it at predictable times, but it usually does it as soon as I scroll down a bit, so I have to scroll up to turn it off. https://www.cnn.com/europe/live-news/russia-ukraine-war-news...
As someone who uses both Rust and C++ frequently with a good understanding of both languages, I can say that Rust is for the mostpart more pleasant to work in, but Rust's handicap is that it makes working in raw pointers when you really have to quite painful.
If you need full raw pointers with aliasing mutable pointers, the fact that fn drop() takes a &mut T is a problem that can only currently be worked around with fugly hacks, like nesting your data type in another pointless structure, not to mention the giant pile of ambiguous UB that you risk whenever pointers and references interact that could so easily be avoided if Rust would just implement an -fno-strict-aliasing switch, but the devs refuse on what appears to be ideological grounds. The result is that for unsafe Rust, you get about the safety level of C much of the time, because RAII and many language facilities are not safe to use. Unsafe Rust is currently so dangerous that I feel much safer reaching for C++ for some of it. Mutable reference uniqueness, I think, should be enforced by the borrow checker and NOT by pain of inescapable possible undefined behavior at the assembler level.
Now for C++.
C++ is lacking a LOT of useful safety features that Rust comes with baked in, such as Mutexes owning their data, the borrow checker, a good, fast atomic reference counting type, and things that translate to more safety indirectly, like algebraic enums, assignable and movable arrays, tuples built into the language, etc. Generics in Rust, however, are significantly more painful to write due to the lack of duck typing. Perhaps the Rust devs felt that duck typing was too "dangerous" for templates, but because they're statically evaluated, these issues almost never materialize, and so in practice duck typed templates are almost always superior to Rust's generics.
C++ is definitely more mature and pragmatic as a language, but Rust is probably better for systems programming overall, at least if they fix their goddamn unsafe UB stuff.
As for move semantics, that book isn't for "what you MUST do to keep things semi-safe!" though it contains some stuff to that effect. It's more about optimization and tricks from what I can see. Move semantics take a little while to wrap your head around, but once you know the basics of C++'s move semantics, you can pretty much figure out what's going to happen by looking at a class' definition briefly.
Haskell gives me headaches. I write a lot of Rust, which has elements of both. I think their approach is pretty good, though sometimes regular inheritance would just be easier.
I don't hate OOP. I don't love it either. I tend to write my code in a mix of procedural and diet-OOP paradigms. It tends to produce less state, less inter-dependencies, and doesn't require abandoning stuff like mutable state.
Why do I want mutable state so bad? Because it's the easiest, least abstracted solution to the problem much of the time, and closer to what the compiler will actually want to generate.
I think trying hard to stick to a single paradigm is folly. I like mixing and matching according to the task I'm attempting to accomplish, and I have a firm conviction that my code benefits from this ideology. Encapsulation I do value, but not as a "hard no". I use access specifiers to tell you "you probably don't want to mess with the guts of this thing, it can take care of itself better than you can."
As for inheritance, I don't use it very often. I like how C++ has no base "Object" class. A lot of the time I'm basically writing structs with methods, and I think that's often the right approach.
Eh. I just cast both to a bigger integer type where possible, which in practice, is almost always. So if I'm averaging two uint32_ts, I just cast them to uint64_t beforehand. Or in Rust, with its lovely native support for 128-bit integers, I cast a 64-bit integer to 128-bit.
The big issue I had with learning Rust is not the simple stuff -- I could write safe Rust fairly quickly. The problem I continue to have is that many internal behaviors of the language are totally undocumented and inexplicable. For example, implicit reborrows. They happen everywhere, but it's still just a pile of unicorn farts as far as documentation. The idea of a language with no documentation for a given syntax is horrifying. Rust does very well in documentation for beginners, but if you actually want to understand the language, if you want to know what's really happening, you're usually fucked.