Pinboard (jm)
https://pinboard.in/u:jm/public/
recent bookmarks from jmacksin/seespot: AWS Spot instance health check with termination and clean up support2017-05-02T10:59:36+00:00
https://github.com/acksin/seespot
jmWhen a Spot Instance is about to terminate there is a 2 minute window before the termination actually happens. SeeSpot is a utility for AWS Spot instances that handles the health check. If used with an AWS ELB it also handles cleanup of the instance when a Spot Termination notice is sent.
]]>aws elb spot-instances health-checks golang lifecycle opshttps://pinboard.in/https://pinboard.in/u:jm/b:85bdeb642f8c/Oops: Instagram forgot to renew its SSL certificate2015-04-30T14:32:28+00:00
http://thenextweb.com/apps/2015/04/30/oops-instagram-forgot-to-renew-its-ssl-certificate/
jmcerts ssl renewal expiry instagram outages lifecycle web httpshttps://pinboard.in/https://pinboard.in/u:jm/b:99a3ab5aa377/Rust borrow and lifetimes2014-11-30T22:34:29+00:00
http://arthurtw.github.io/2014/11/30/rust-borrow-lifetimes.html
jmRust achieves memory safety without GC by using a sophiscated borrow system. For any resource (stack memory, heap memory, file handle and so on), there is exactly one owner which takes care of its resource deallocation, if needed. You may create new bindings to refer to the resource using & or &mut, which is called a borrow or mutable borrow. The compiler ensures all owners and borrowers behave correctly.
]]>languages rust gc borrow lifecycle stack heap allocationhttps://pinboard.in/https://pinboard.in/u:jm/b:cf250eeb69f7/#AltDevBlog » Parallel Implementations2014-06-16T09:09:16+00:00
http://www.altdev.co/2011/11/22/parallel-implementations/
jmThe last two times I did this, I got the software rendering code running on the new platform first, so everything could be tested out at low frame rates, then implemented the hardware accelerated version in parallel, setting things up so you could instantly switch between the two at any time. For a mobile OpenGL ES application being developed on a windows simulator, I opened a completely separate window for the accelerated view, letting me see it simultaneously with the original software implementation. This was a very significant development win.
If the task you are working on can be expressed as a pure function that simply processes input parameters into a return structure, it is easy to switch it out for different implementations. If it is a system that maintains internal state or has multiple entry points, you have to be a bit more careful about switching it in and out. If it is a gnarly mess with lots of internal callouts to other systems to maintain parallel state changes, then you have some cleanup to do before trying a parallel implementation.
There are two general classes of parallel implementations I work with: The reference implementation, which is much smaller and simpler, but will be maintained continuously, and the experimental implementation, where you expect one version to “win” and consign the other implementation to source control in a couple weeks after you have some confidence that it is both fully functional and a real improvement.
It is completely reasonable to violate some generally good coding rules while building an experimental implementation – copy, paste, and find-replace rename is actually a good way to start. Code fearlessly on the copy, while the original remains fully functional and unmolested. It is often tempting to shortcut this by passing in some kind of option flag to existing code, rather than enabling a full parallel implementation. It is a grey area, but I have been tending to find the extra path complexity with the flag approach often leads to messing up both versions as you work, and you usually compromise both implementations to some degree.
(via Marc)]]>via:marc coding john-carmack parallel development evolution lifecycle project-managementhttps://pinboard.in/https://pinboard.in/u:jm/b:bde686da6276/