breatheoften

classes are a bad way to model data imo

I wish python had a clean way to define types without defining classes. Think a _good_ mechanism to define the shape of data contained within primitives/builtins containers without classes -- ala json/typescript (ideally extended with ndarray and a sane way to represent time)

Python classes wrapped around the actual "data" are sometimes necessary but generally always bad boilerplate in my experience.

I think the whole concept of source files as unordered blobs on the filesystem is just _wrong_ -- and a serious drag on the ability of a reader to quickly digest a codebase and make inferences about changes in isolation ...

Codebases are _ordered_ constructs -- regardless of the ridiculous broken build system abstractions that do everything possible to obscure this truth ...

I'd imagine the main use case is to whitewash insider trading signals ...

Is there anyway to fully disable youtube shorts/reels/whatever that mess is called ...? I quite like youtube long form content but have found myself occasionally in short form rabbit holes (which are both very addicting and extremely unsatisfying and which motivated me to delete instagram to escape when i realized how much a time and emotion suck they are)

What i want to know is how long does it take for this kind of dip to show up in real estate prices -- there's a certain amount of loss in that sector (not all that large) before the downward trend in asset prices becomes self-accelerating -- unless banks and lenders put in policies to actively avoid putting out margin calls and the like

How exactly do you accidentally add a reporter to a signal group chat ...? That's a pretty bizarre sequence of events if it's actually what happened isn't it?

I wonder if with 177TB you could implement DOOM in a regex ... (plz don't try unless you want to be on top page of hackernews in a year!)

I remember this paper being discussed in the novel "Science of Discworld" -- a super interesting book involving collaboration between a fiction author and some real world scientists -- where the fictional characters in the novel discover our universe and its rules ... I always thought there was some deep insight to be had about the universe within this paper. Now moreso I think the unexpectedness says something instead about the nature of engineering and control and human mechanisms for understanding these sorts of systems ... -- sort of by definition human engineering relies on linearized approximations to characterize the effects being manipulated -- so something which operates in modes far outside those models is basically inscrutable. I think that's kind of expected but the results still provoke the fascination to ponder the solutions super human engineering methods might yet find with the modern technical substrates.

Super supportive as I really value debuggers as tools even tho they are horror shows to use!

> Similarly, the following features are non-goals of the project:

> Supporting non-native languages (i.e. Java, Python, etc.)

But I think that position is likely a mistake in terms of leaving killer features on the table and baking in architecture decisions that might continue to make these kinds of features impossible / very low-class experiences.

Properly integrating with the python interpreter to be able to debug python + c/cpp extensions running in the same process is a huge missing whole in the debugger market.

I don't know how other people do it but I 'solve' this problem by attaching either a python debugger or lldb to the python process -- meaning I can debug either python or the cpp but not both at the same time. The experience is very lacking. Even just seeing the python call-stack while paused at a cpp breakpoint would be huge.

I'm sure it factors into the calculus of the sellers -- best chance they have that there might exist an irrational buyer onto whom they can unload the losses is likely now ...

I just wish they'd improve the markdown autocomplete for issues and pull requests ... I'm not sure why it's so bad but even if i know two or three words in the issue title i almost never get the right issue to choose in the autocomplete list while typing in a markdown comment ...

I didn't notice any barcodes -- it looked just like a ballot a human would fill out but with the bubbles filled in as part of the printing

Googling around I think colorado banned ballots with qr codes / non human readable machine encodings .. or at least banned use of them for tallies

https://securitytoday.com/Articles/2019/09/18/Colorado-Becom...

I voted early in person in Colorado a few days ago. Use a machine to entry my votes. Votes were printed onto a piece of paper. I checked to make sure the marks on the paper matched what I entered into the machine and then dropped it into the ballot box (not a machine just a box that collected the ballots). It was pretty sane and didn't seem like there was a lot to worry over related to the electronic entry system.

As to how the votes on the ballots are tallied - if those machines are compromised seems like a definite problem -- though there is at least the option to hand count the ballots to compare against ...

Why does it take 4 minutes (after being optimized from 8 minutes!) to move a 30 GB (compressed) docker image ...? The read slowness of docker registries continues to surprise me ...

What's the short summary of how the authorization system works for this?

One of the things I find quite nice about firebase is the quite powerful separation between the logic of data retrieval / update and the enforcement of access policy -- if you understand it you can build the prototype on a happy path with barely any authorization enforcement and then add it later and have quite complete confidence that you aren't leaking data between users or allowing them to change something they shouldn't be able to. Although you do need to keep the way this system works in mind as you build and I have found that developers often don't really grasp the shape of these mechanisms at first

From what I can tell -- the instant system is different in that the permission logic is evaluated on the results of queries -- vs firebase which enforces whether the query is safe to run prior to it even being executed ...

I recently added some pretty printers for a type we have a lot of in our codebase (the c++ Eigen library).

Unlike the article we are using lldb rather than gdb ... and while I appreciate thats its possible _at all_ to script the debugger to do some pretty printing -- I found it quite a bit more frought to implement than initially expected ...

To take the Eigen example ... Eigen is a 'header only' library and offers Templated vector and matrix types. The types are template over (optionally), data type, number of rows, number of columns, and matrix row order (row major or column major). All that information is not actually even available at runtime -- just the type name (with the instantiated values for template arguments) ...

I ended up having to super hackily parse information out of the template type name in order to be able to pretty print the matrix appropriately in lldb ...

Problems of this nature abound when debugging c++ ... Very often with a header only library, there isn't even a symbol for methods you might want to call -- so you want to eg, call the size() method on some object within the debugger to see how big it is, you'll often be out of look due to an undefined symbol reference since the 0-overahead compilation models ensures the symbol doesn't even have to be created in the binary ...

Would be nice if there was some kind of way around that -- I guess I need to try the workaround mentioned in the article of explicitly instantiating template classes for common classes in 'debug' mode ... My fuzzy mental model derived from previous experience somehow doesn't think that will actually help the issue tho -- but I'd be happy to be wrong!

On what does a tangerine wait Each morning below the winters sun as it awakes?

Do twisted dreams linger, of what it might mean to be a taste on the memory of a forgotten alien tongue?

Is its sacred role seen -- illuminated amongst the greens and unique chaotic chrominance bouncing ancient wisdom between the neighboring leaves?

The tangerine -- victim, pawn, and, ultimately, master ; its search for self in an infinitely growing pile of mixed up words truly complete. There is much to learn.

I think it's a pretty good name for the phenomenon -- maybe the only problem with the term is that what models are doing is 100% hallucination all the time -- it's just that when the hallucinations are useful we don't call them hallucinations -- so maybe that is a problem with the term (not sure if that's what you are getting at).

But there's nothing at all different about what the model is doing between these cases -- the models are hallucinating all the time and have no ability to assess when they are hallucinating "right" or "wrong" or useful/non-useful output in any meaningful way.

I just reread this after seeing it on the shelves of a coffee shop bookstore I frequent.

I remember originally reading this sitting on the floor of a library while on a solo trip through England as a teenager ... I spent the rest of the summer reading everything by Greg Egan I could find. He's my favorite author and I can honestly say I think his books have had more influence on the way I think than any other author.

Re-reading axiomatic after all these years brings with it a surge of memories from the younger me. It's awesome to have this kind of talisman that provides a powerful connection to the states of mind of my youth and the things I thought as I grappled with these ideas, so many really for the first time. There is very little literature that goes so far and deep into the experience and philosophy of thought as Greg Egan.

Amazing that this was written in the early 90s -- and still has a better sense of life with recent and upcoming technology that most stories written much more recently ...

Is there a way to use this to capture just hashes of the code (transitive) that implements a particular function?

I can't buy into a whole framework in my current context -- but I would really like a way to roll my own content hashing for adhoc caching within an existing system -- where the hash will automatically incorporate the specific implementation logic involved in producing the data i want to cache (so that the hash automatically changes when the implementation does).

eg -- given python function foo -- i want a hash of the code that implements foo (transitive within my project is fine)

I'm using google's artifact registry -- aside from upload speed another thing that kills me is freakin download speed ... Why in the world should it take 2 minutes to download a 2.6 GB layer to a cloud build instance sitting in the same region as the artifact registry ... Stupidly slow networking really harms the stateless ci machine + docker registry cache which actually would be quite cool if it was fast enough ...

In my case it's still faster than doing the builds would be -- but I'm definitely gonna have to get machines with persistent local cache in the mix at some point so that these operations will finish within a few seconds instead of a few minutes ...

The EV charging planning features while route planning still seem pretty necessary with the current level of deployed charging infrastructure (at least in the US) ...

I don't think at least CarPlay has anything able to meet the actual need there or even a way to provide something that would ... Maybe a separate map app that ran inside carplay to provide the required featureset?

Strongly pro rebase here.

I sometimes wish I could require squash merging to main so that history on main is fully linear -- however the fatal flaw with doing that is that it becomes impossible to know from git history whether a given branch has actually been merged to main or whether it was abandoned and left to dangle and rot forever. The inability to observe merge state for a given commit increases the effort required to know whether some given piece of work was merged (or at least requires using mechanisms that are not native to git to make such a determination) and complicates cleaning up old local branches after they are merged. If you use a graphical git client then seeing a brunch of old local branches that are already merged everywhere is noisy and distracting. When real merges are done then can easily write a script to remove all the branches that are already merged to main which helps to reduce noise and maintain better focus and faster navigation.

Other strategies to discourage the usage of properties as investment have existed at various times ... Things like squatters rights laws have been deployed for this purpose in some parts of the world at various times (Netherlands for example had quite large movements where the youth would occupy empty homes owned by rich investors in order to take advantage of favorable (to the squatters) laws -- which discouraged folks from sitting on unoccupied investment properties home at least at some historical points in time

It would definitely be possible for government to be good at things ... in the olden days of tech development, very good people were employed and empowered at government positions with technology roles. I'm thinking back to later 90s when I filled out my financial student aid application. That was an _extremly_ complicated web product for the time, built entirely by the government, and it completely worked and was easy to use. Commercial products like turbotax on the web didn't get parity of complexity and robustness for a good decade more than that.

The 'outsource everything' 'not allowed to compete with private industry' mentalities are what has the made the government unable to function in a quality manner ... Its virtually impossible for the government to just hire some people to a team to build some shit -- instead they are _required_ to create bids for contractors to bid on and then incredibly formal contract management processes that are just incredibly disfunctional by design ...

It doesn't have to be this way -- its a political result going back to the 'small government' movement which was ultimately about proving that government has to be bad at everything by imposing rules to ensure that result in as many places as possible ...

What does "for later use" mean?

One thing I've noticed recently is that pretty much no language has a good way to simultaneously define a nested structure and assign that structure a name "for later reuse".

For example -- suppose I'm dealing with some serialized data structure that come from some external system. Very likely the data model behind this value involves "nested values" which have themselves have some type of which might be reused in multiple places by that external system.

When the goal is to just solve problems -- the approach i like to take is to focus on the values i want to consume and produce -- which might themselves contain lots of nested types each with some amount of reuse ...

I'd really like a language feature that supports simultaneously defining a type where it's relevant within some other data structure _and also allows_ giving that embedded thing a name for independent reuse ...

I wonder if this postfix $ syntax is related to that use case at all ...

(... this comment a speculation based on names of things only without even reading the whole article ...)

I think this article makes some really valid points. Many languages try to address the spooky action at a distance type errors by requiring explicit annotation of types at certain boundary type conditions like function argument and return arguments -- which can help but can still also being annoying when the type system knows the types you want to write but you still have to figure them out and type them in yourself. A lot of times it's less cognitive load to verify that a type declaration is what you expect than it is to write it yourself (something we often do with tools like rust-analyzer or highlighting over variables in ide to see the type).

Personally I'd like to see languages embrace "format on save" as an explicit part of language ui to improve ergonomics here. Firstly, a first class auto formatting tool is just great and spamming cmd-s as you write code until it auto formats nicely is a really quick way to observe and address syntax issues -- to me that part of the experience is already important enough to explicitly incorporate making that developer experience work well a goal of language design.

But secondly -- if you do embrace auto format on save at language design level, there's a lot more you can do than just auto format the code! You also gain a really nice channel for communicating information about "program change" to the developer. Say you allow in the language to differentiate between inferred and not inferred types -- and then at auto format time, the inferred types are explicitly added to the code (in some heuristically useful set of places-- or even just everywhere that a non type inferenced language would require explicit types).

In that world, as you make changes to the code, your git diff state is going to start giving you a lot of potentially useful feedback about what actually happens in your program when you make certain changes. Additionally because the inferred types are automatically added -- you can easily have a mode to hide them when you want a less noisy view. Mayb the convention would become that committeed code is always serialized to a form that conveys more of the statically knowable program information by default -- which your ide can hide to give you a more streamlined view -- rather than the other way around). And then the parts of your code you know are boundaries or apis or not expected to change types, you just update the annotation to indicate that the type is not supposed to be reinferred and a type error will be issued if it doesn't match instead of being updated. Now you've got a nice way of constraining program evolution in desired directions to help tame complexity or at least force explicit acknowledgement as certain assumptions about the program structure become invalid over time ...

Improving the accuracy and robustness of gps on mobile devices -- https://www.zephr.xyz/

Real physics and computational communication problems. Crazy tech, fun stuff!!

I used this tool recently to debug some issues where one of our batch tasks was using more memory than it should and sometimes OOMing in an environment where it shouldn't come close to hitting a memory ceiling.

Found the issue almost immediately with the high watermark analysis which provides visibility into the part of the codebase/call stack that allocated every bit of allocated memory that was still live at the high watermark time. Made diagnosing the issue (an unexpectedly large amount of memory required when using a method from a third party library -- xarray.merge) and remedying the issue incredibly easy.

I was very impressed by the quality and utility of this tool and am now a huge fan!

I discovered their podcast a month ago and binged through the backlog -- it's one of the best technology podcasts of all time! Really like the way these folks think and communicate!