1,678 karma · joined January 5, 2015
The article describes the mental model needed to understand the operation of the swift type error diagnostic system with a high level of clarity.
Thinking through how this system works provides a super valuable learning experience for a wide audience of readers.
There is so much code that is not part of the codebase driving the behavior of the system — and that third party code is very tightly coupled to the actual behavior that will be observed by running the code. Figuring how anything actually works is made massively harder than required and developers are encouraged towards designs that will require ridiculously inefficient database interactions.
Rails is terrible I think for experienced developers because there are no mechanisms in the codebase — instead there are layers and layers of “conventions” which often only exist to try to avoid bugs that would’ve been much better to catch or prevent with a combination of a type system, high level tests, and less mutation.
With a good query builder in hand - it is very unclear to me why anyone would ever want to use an orm.
Very jealous of Ft Collins ...
Maybe you can get away with a module system that works that way in something like ocaml where it’s always possible to tell what is being referred to statically — but in a dynamic language - the level of obfuscation this induces is absolutely nuts
I spent two weeks working remotely recently and had to use this keyboard rather than my old, excellent, pre-bufferfly switch external Apple keyboard (link for anyone curious — you can still by their old/good usb keyboards on amazon — https://www.amazon.com/gp/aw/d/B07K7V1FWC?psc=1&ref=ppx_pop_...). My hands and fingers were noticeably more fatigued after using the terrible keyboard. My coworkers commented about how much more typos they noticed in slack than normal.
I absolutely hate this computer — not in a “complain about little things that bother me way” - in a “this device is by far the least favorite apple device I’ve ever owned” kind of way. I dislike this computer at every level not because small issues — because of large, major, fundamental problems.
You might have to fix a bunch more errors but at least those are easy to fix (just add any explicitly to the type — or better yet, add the real type if it’s obvious) ...
Obviously cdp only applies to the communication mechanisms relevant to control a browser — i guess what I’m musing about is wanting to Suss out - is there anything that will be lost (dx feature support, performance) if one attempts to implement ide features but using debug adapter protocol to adapt CDP? Is CDP one of the target integrations that debug adapter protocol will aim to support?
I think CDP is ridiculously important and likely to become more so ...
What is the role of architect in the real world? In some high profile cases they are designers - even to the point of doing something like project management/business development (the only reason we funded this project is because of the awesome ideas we got from the architect, we worked with the architect to make sure the building would meet our dreams for this project ...). But more commonly — I understand their role more in construction to me more in the realm of being a maintainer of documentation — maybe they have some role in proposing the original design but the majority of their time is probably spent ensuring that these plans satisfy all required regulations — and updating the plans in response to what actually happens during building so that the building itself will pass all regulations ...
This is nothing at all like the nebulous responsibilities generally associated with software architects. Some projects could benefit from this level of book keeping requirement — but a lot of projects which contain “software architects” probably would reject paying someone to maintain specifications to a similar level of accuracy as is required of real world architects — especially if that was basically all that was being asked of them to do ...
I don’t think the issue here is the use of c++ — it sounds to me like it’s the use of c++ on problems that would have been far simpler solve on the native code ... not all problems are that way — but even where it makes sense to solve with c++, you have to be careful about the glue.
I developed and maintained cross platform c++ for iOS/Android in a previous role and the platform to native glue is inherently complicated — among the most complicated parts of the program to reason about if you get into the details of it. I solved by making this layer dead simple — you could almost never pass objects in or out — just primitive values.
The c++ layer exposed to platform was just static methods — including a bunch of methods for retrieving state and we added more static methods when new kinds of communication were required. Every c++ method grabbed the largest lock it could prior to doing anything natively (and in debug mode related methods associated with some kind of stateful lifecycle would fatalError if they couldn’t get the needed lock — the app code shouldn’t have been calling into native code in a way that violated simple assumptions about how the state was allowed to change).
Interestingly — this forced the platform layers above to comply with the assumptions needed to keep the native code simple — and helped those working on the UI immediately find out when they were violating these assumptions — things like click handlers that weren’t debounced or weren’t switching to a disabled mode after being clicked — when those click handlers invoke native code and that native code mutates state — you have a potential nightmare scenario for robustness ...
This model actually was quite straightforward to add new functionality to over time and we frequently moved decision authority over complicated logic into the native layer so that we could make it robust and cross platform ...
The knowledge exists that we shouldn’t be encouraging systems to be built with the patterns/tools commonly advocated in the python world — at what point do we acknowledge that the forces promoting this kind of ecosystem are essentially propaganda-like mind viruses ... so much future suffering that will not be prevented ...
Lots of regular expressions were used before and without control of the documents (which change over time) this kind of code was just unmanageably difficult to maintain.
Being able to use negative look ahead with lists of grammar symbols provides an incredibly large amount of power to resolve ambiguities and makes it relatively easy to arrive at an explainable grammar capable of handling “every sample we’ve seen so far drawn from an only partially observable language” ...
Projects which are updated often have a forcing function on them - they need to become updateable ... that can mean tests, that can mean reasonable build tools, and that can mean dropping individual dependencies that are too painful to update.
Obviously some ecosystems make all these things easier than others — typed languages with reasonable consistent build processes help more than anything. Good codebases that isolate and wrap usage of most dependencies next and reasonable automated tests probably next most useful.
It is definitely the case that some codebases are easier to update than others even given the same ecosystem/dependencies. When is the pain of “churn” most reasonably considered my fault instead of yours? Those are the situations can be fixed and they can get you pretty far — much further than “ahh, this codebase has javascript and webpack i shall rewrite with make and closure” can get you on average ...
The polar star tho — that thing barely looked like it floated — mad respect to the people who keep that working and the amount of suffering that must involve ...
One of the things that was strange to me about the Healy was the crew rotation schedule — there was very little continuity of personnel with military design of all people must be on temporary assignments and therefore easily replaceable ... seems like they can’t possibly do that with a ship like the polar star where the deep ship specific knowledge _has_ to be on board ...?
You suggest that we should sacrifice the rigor of pilot training to allow delivering planes without safety compromises ... I think there’s absolutely no justification for safety compromise in this scenario - the new plane will pay for retraining costs in a slightly longer amount of time than it would’ve had retraining not been required — oh well. That’s the cost of doing business and it’s absolutely without doubt that in this case - designing a plane that wasn’t inherently flawed would’ve been a better strategy for Boeing and for all of their 737 Max customers ...
The real question to learn from this tragedy is not how can we make it slightly less expensive to produce a new air frame — it’s how can we ensure that safety is not allowed to be compromised during the design phase of new passenger aircraft in service of _truly_ minor cost savings ... if we had a real regulator that was not captured - they should’ve had the flexibility to say no to the 737 Max very very early in the proposal process — and if necessary they should’ve been allowed to offer a tax incentive to offset some of the pilot retraining cost required by them not budging on safety requirements.
Building and deploying safe airplanes into real world use is more expensive than building unsafe airplanes — but that doesn’t mean it’s not worth the cost to society...
It’s deeply sad to know that future generations won’t have as much opportunity as I had to enjoy life ... but to pity them will feel patronizing to them - and so what is left for them to know of me and me to know of them ...?
Dear citizens of the future, know that some of us are sorry for how your life will go — and know that some of us are not for they got theirs before you arrived and that was enough for them ... for some of us this wasn’t enough - we lived your pain in our imaginations while enjoying a physical life of abundance that, in the end, has helped you in no way at all ...
If they are doing 96% of the safety validation work — then they should bear 96% of the responsibility for safety process failures ... in this case, given the break down of safety validation capacity and what I’m increasingly viewing as essentially a coverup after the first and second crashes — 96% of the responsibility is and probably should be - enough to bring Boeing down ...
I’m beginning to think that might be the only way to ensure responsibility for this failure gets allocated in a sufficiently accurate way to ensure this scenario isn’t likely to happen again ... allowing the faa to have the responsibility to bear the weight of this process breakdown would basically just allow Boeing to shift responsibility for this outcome off themselves and onto an organization which it seems has been deliberately engineered (by Boeing) to not have the capacity to perform effective oversight ...
I still really struggle to understand what the practical benefits to this kind of containerization actually are ...
It seems like people reach for it because they want to have some kind of “compile target” into which they can stick “all the things” their application needs to run — which is supposed to then help them “deploy” into their development environment or onto their production infrastructure in a way that serves the goal that the applications within the image should behave the “same way” in either location ... but does anything about this kind of container abstraction actually help with doing this? Don’t you still inevitably end up having to manage assumptions about the differences between these environments in order to make this work in practice (oh if you are in development environment make sure you don’t actually submit payment to stripe, if you are deploying to this cloud provider make sure you get secrets from <here> instead of <here> ...) ...?
Do you actually get any good abstractions out of the container which empower better solutions to deployment challenges? “I don’t have to think about which hosts the (random) http client used in my application is configured to talk to because I can just magically retarget it at the container level by manipulating networking configuration” — is that a thing — does it actually work? To my understanding the extent to which you _can_ do that requires you to write your application a certain way with a crazy service discovery layer like istio — and you’ve got to make sure you build your application completely to use service discovery fabric ... but if you built your application to use a service discovery fabric do you gain anything extra by also using docker at that point ...?
And what about the impact to developer ergonomics? Is it easy and smooth to use debuggers to quickly edit code running in an image ...? Do people regularly run production docker images locally to debug production application issues ...? Are there solutions that allow one to say, attach to a remote qa testers chrome instance and then automatically attach debugger to the set of production containers handling the requests associated with that browser ...?
Those are the kind of features I want ... I’m not sure exactly if the containerization abstraction model would really help me get there or just create another set of configuration knobs that _also_ have to be correctly aligned for me to get the right environment specific behaviors out of my application ...