Atomic Spin

Atomic Object | Developer, Designer | Ann Arbor, MI ; Grand Rapids, MI | ONSITE | Full Time We are a custom software design and development consultancy. We do a full range of development from high level design prototypes, down to low level firmware on embedded devices and everything in between. Want an idea of the work we do and the technology we work with? Check out our blog: https://spin.atomicobject.com/ Being an Atom: Atomic doesn't ask that you know a certain language or use a certain process. But we are looking for a certain kind of person—someone who embodies our culture and values. Atoms give a shit about their work, their teammates, and their clients. We pull together. Atoms are generalists who enjoy learning and doing new things. Atoms are great communicators, able to work effectively one-on-one with clients and users. Atoms are product developers, working on poly-skilled teams to create the most valuable product possible with the client's budget. Interested in applying? Check out our careers page: https://atomicobject.com/careers

Somewhat relevant about how GCs work, with also very great visuals: https://spin.atomicobject.com/2014/09/03/visualizing-garbage-collectio…

Coverage numbers are misleading (to the point that I find they did more harm than good). There are definitely cases where you can't (or aren't clever enough to) express what makes your business logic valid in the type system and need to write a test, but IME they're the exception rather than the rule (both because you generally can encode things in types, and because the majority of code ends up being "plumbing" with no real business logic anyway); I like to follow something like https://spin.atomicobject.com/2014/12/09/typed-language-tdd-part1/ .

Having recently switched to Git on Windows, you miss out on these great resources. Thankfully with all the Git information floating around it's easy enough to find answers. One such page is this one containing three good tips https://spin.atomicobject.com/2020/05/05/git-configurations-default/

Various C/C++ programming safety standards (such as MISRA C), specify a single return only. [0] is probably the best defense of the position I could find quickly, but the example used is convoluted, and very much "look what happens when you allow multiple returns". I personally like to use early returns as guard statements when I'm doing precondition checking or on errors. [0] https://spin.atomicobject.com/2011/07/26/in-defence-of-misra/

I really like being able to 'tent' my keyboard like the Kinesis keyboards[1] - the higher the better. So I'd love a split model if one is available. [1] https://spin.atomicobject.com/2018/02/11/review-kinesis-freestyle-edge…

A great time saver for me was simply setting up better bash history and search capabilities[1]. I wrote a wrapper function, sbh (search bash history) that allows me to input date strings like "2 months ago", or "last week", which narrows the search. Linux 'date' function with --date string arg is pretty powerful[2]. 1 - https://spin.atomicobject.com/2016/05/28/log-bash-history/ 2 - https://www.thegeekstuff.com/2013/05/date-command-examples/

First blog I thought of, although it's not a company: Dolphin. https://dolphin-emu.org/blog/ As for actual companies, as an embedded dev I think Atomic Object (https://spin.atomicobject.com) and Free Electrons (http://free-electrons.com/blog/) both do a good job.

Neat series. There was another recent post on using a C# version of Redux as well, at https://spin.atomicobject.com/2017/03/13/adapting-redux-c-sharp-xamari… . It's nice to see Redux's concepts spreading outside the Javascript world. I've had similar thoughts regarding some of the Python services I work with. If anyone is interested in learning Redux (or React), I keep a big list of links to high-quality tutorials and articles on React, Redux, and related topics, at https://github.com/markerikson/react-redux-links . Specifically intended to be a great starting point for anyone trying to learn the ecosystem, as well as a solid source of good info on more advanced topics. I also maintain a catalog of Redux-related addons, utilities, and tools, at https://github.com/markerikson/redux-ecosystem-links .

Thanks, really appreciate the effort to provide your take on the problem. While I could easily see this working with friends, it not really what I'm looking for. Here's so far here's the best expression of why I don't sign NDAs: https://spin.atomicobject.com/2014/09/08/nda-stifle-creativity/

I wrote an article about mean-shift a while back if anyone is interested in more details about it - https://spin.atomicobject.com/2015/05/26/mean-shift-clustering/ Some comments on K-Means - one large limitation of K-Means is that it assumes spherical shaped clusters. It will fail terribly for any other cluster shape. It's interesting that the author compared results on the same data set for the different algorithms. Each clustering approach is going to work best on a specific type of data set. It would be interesting to compare them across several different data sets to get a better feel for strengths/weaknesses, etc.

Another interesting read in this space is http://spin.atomicobject.com/2013/07/31/greatest-c-testing-embedded/ (his header-only unit testing library is at https://github.com/silentbicycle/greatest)

Strange, most blogs that I've read discuss the pain involved. http://spin.atomicobject.com/2014/06/06/f-sharp-mono-unix/ I guess it's the same with any new product or language: when there are a lot more great testimonials than cries of pain, then it's actually safe to use that product.

i learnt about them from this post and the library it refers to: http://spin.atomicobject.com/2014/10/08/c99-api-designated-initializer… good read, both the post and the socket99 code.

I subscribe to a bit of both -- the Broken Comb approach. Being a little of everything but never getting deep into anything is just as dangerous as being a one-trick pony. http://spin.atomicobject.com/2013/06/27/broken-comb-people/

Author of greatest, here. I wrote a blog post about it a couple months ago: http://spin.atomicobject.com/2013/07/31/greatest-c-testing-embedded/

Good points. Makers need to make and use their creativity ( http://spin.atomicobject.com/2012/04/08/do-what-you-love/ ). We cannot just be butts in seats. The 501 guys seem to want to just be a cog in a machine, but that is not enough for me. I think other makers would agree.

Often when writing scripts, I'm chaining tools together, e.g. using git to find a thing in a specific commit, using curl to grab something from the web, decoding some json, maybe unzipping a file. I've never really found any language that feels good for that kind of thing, there's definately a middle ground where it's getting too much for bash, but jumping to a language loses too much at the initial conversion to make it feel worth it until you are well past the point where your future self will think you should have made the switch. Some languages have things like backticks in php to inter-operate but it's still not great experience to mix between them. For my own little things I'm currently looking at fish, but bash is omnipresent. This tool seems to delay that point even further, as currently dealing with generating json is definately a pain point (whereas manipulating it in jq is often really good). But if anyone can point to good examples of this transition in python then I'd be very interested. edit: jq is more powerful than I thought for creating json, see https://spin.atomicobject.com/2021/06/08/jq-creating-updating-json/

Some alternatives are: * Just keep your architecture a monolith. You'll do fine the majority of the cases. * Event-sourcing doesn't require Kafka clusters. Nor do event-driven setups. You don't need complex tooling to pass around strings/json-blurps. An S3 bucket or a Postgresql database storing "Events-as-json" is often fine. * Postgres can do most of what you need (except for the "webscale" clustering etc)[0] in practice already. * Redis[1] My main point is that while Kafka is a fantastic tool, you don't need that tool to achieve what you want in many cases. > It seems as good a way as any to decouple systems IMO relying on a tool to achieve a good software design, rather than design-patterns, is a recipe for trouble. If anything, because it locks you in (do you suddenly get a tightly coupled system if you remove Kafka?) or because its details force you into directions that don't naturally fit your domain or problem. -- [0] https://spin.atomicobject.com/2021/02/04/redis-postgresql/ [1] https://redis.com/redis-best-practices/communication-patterns/event-qu… etc.

Personally, I think this is very dependent on the culture and work practices of the company in question. I agree that for the average company, training is very expensive. But I don't think it's universal. If you have a strongly cross-functional, collaborative team, then a new person isn't nearly as much of a problem to bring on. As an example, Atomic Object is a midwestern software development shop that follows practices like pair programming, collective code ownership, short iterations, and a lot more. For them, interships and apprentices aren't a big problem, and have been key to their growth: https://spin.atomicobject.com/2011/10/04/interns-and-apprentices-at-at… I also think it's worth looking at why people change jobs. I agree it's common, but I also believe that sucky jobs are common. If people leaving is such a problem, I'd like to see companies put more effort in to making them happy where they are. Not only would that be the humane thing to do, but it would make the ROI on investing in employees higher.

I've had good experiences with Yubikeys thus far. I still have two of the Symantec VIP tokens from years ago that I've never had issues with. I recently bought a Neo to test out NFC (NFC support on the HTC 10 seems deplorable for smart card reading btw). I also purchased a few 4c tokens and so far they've worked great although I haven't been using them for very long. The gotchas I've encountered while using them on OSX: - The pins for PIV and OpenPGP are separate as these are separate modules on the card. - You can't use the PIV or NEO GUI managers and gpg at the same time. You might have to unplug and plug the token back in when switching back and forth between GUI/cmdline Yubico tools and gpg. - Forgetting to change my environment to use gpg-agent instead of ssh-agent. - Typing in my local password instead of the PIV pin when logging into OSX while I have a token with PIV enabled plugged in. The "setup" instructions that are referenced in the packaging and on parts of the site are for basic use of OTP. Real documentation is here: https://www.yubico.com/support/knowledge-base/categories/guides/ For people asking about backing up material on OpenPGP modules: these are write only. Generate your material locally with gpg instead of generating them on the smart card itself and use the keytocard command to copy the keys to the card. You can backup your keyring prior to moving keys and restore it before copying keys to each card or ctrl c out of gpg without…

Specializing, I think, is a good thing. I'd long been beholden to the belief that "broken comb" (https://spin.atomicobject.com/2013/06/27/broken-comb-people/) could lead to a fulfilling career path, but I no longer believe this is the case. If you're middling at a bunch of things then you'll never be hired to greater than a middling position. The only advantage of broken comb is that you potentially have lots of middling positions you can apply to. But even for those, you may be rejected as "overqualified" because you know so much other stuff. Besides, who wants to send lots of resumes and do lots of interviews in the pursuit of a middling job? Especially when you know you're way better than the people that you're competing against and losing to. So, don't fan too far out. Find a concentration that's reasonably mainstream for the foreseeable future and expand your skillset to supplement that. Maybe not as renaissance-man as the typical above-average programmer would hope for, but likely the best career path.

I've recently developed a renewed interest in iOS development particularly because of ReactiveCocoa. The idea of declaratively describing the intent of an action, rather than how it should work, has helped things "click" for me and I'm looking forward to using FRP and ReactiveCocoa in building a few personal iOS projects. I'm continuing to read more about it and this post was very helpful, thanks for sharing. I have a couple additional questions for any seasoned iOS / ReactiveCocoa / FRP devs that would definitely help me along as I progress: 1) Are there any performance gotchas or things to look out for when embracing ReactiveCocoa? One thing thats stuck with me as I read is making sure to understand and keep and eye on memory management, even after embracing ARC. Is debugging ReactiveCocoa code any different than the normal imperative way? 2) What parts of an app shouldn't be handled with FRP? Should everything fit into the framework or is a code smell to handle things both ways? 3) I'm a Ruby Dev and I'm looking hard at RubyMotion as a good toolchain for iOS Dev. It looks like ReactiveCocoa and Rubymotion can play well together[1], but is this a hack? Is there any issue with using Rubymotion and ReactiveCocoa together. Seems like a great fit, but perhaps my inexperience isn't aware of a deeper issue. [1] http://spin.atomicobject.com/2013/06/18/reactivecocoa-rubymotion/

There are some interesting solutions out there, such as bit-banding used in some ARM Cortex CPUs. This maps entire bytes in the high part of the address space to single bits in the low part of the address space, so that you can make an atomic set or clear of a single physical bit by writing to a byte of memory. https://spin.atomicobject.com/bit-banding/

I'm using a snippet from this page: https://spin.atomicobject.com/2016/05/28/log-bash-history/ export PROMPT_COMMAND='if [ "$(id -u)" -ne 0 ]; then echo "$(date "+%Y-%m-%d %H:%M:%S") $(pwd) $(HISTTIMEFORMAT= history 1)" >> ~/.logs/bash-history-$(date "+%Y-%m-%d").log; fi' This give an easily greppable shell history. An entry looks like this: 2022-10-13 09:14:54 /home/bhaak 1000 vim ~/.bashrc

Check out: https://spin.atomicobject.com/2016/08/26/makefile-c-projects/ https://make.mad-scientist.net/papers/advanced-auto-dependency-generat…

It is typically because you have more than one of the same monitor with identical EDID information. Documented and explained here: https://spin.atomicobject.com/2018/08/24/macbook-pro-external-monitor-… Possible fix: https://gist.github.com/ejdyksen/8302862?permalink_comment_id=3758227

There is another site with graphics linked at the bottom of the article https://spin.atomicobject.com/2014/09/03/visualizing-garbage-collectio…

At a given point it does look like ARC might be the easiest solution (sure it has problems, but they're a subset of GC's problems) Edit: this link posted by another commenter gives a nice overview of the tradeoffs between the methods and it has very nice graphs to boot https://spin.atomicobject.com/2014/09/03/visualizing-garbage-collectio…

And here I thought this was going to be about the HDMI YCbCR issue. https://spin.atomicobject.com/2018/08/24/macbook-pro-external-monitor-…