HNHacker News
TopNewBestAskShowJobs

robmccoll

1,411 karma · joined June 5, 2014

www.robmccoll.com

[ my public key: https://keybase.io/robmccoll; my proof: https://keybase.io/robmccoll/sigs/rFoGh_YBcy3PiVvcUp7vfPqM_pDQqXXNuHrkyeB756I ]

submissionscomments
robmccoll··on On a great interview question
The best interview question I've ever heard: Someone is sitting shopping online with their cursor hovering over "Add to Cart". From the moment they physically click on it to the moment the page refreshes, tell me everything you can think of that happens.

Responses are awesome because it gives you an idea of what this person's background is and what breadth of knowledge they have and what they think is cool or exciting. Maybe they start with a contact closing and signals being denounced, or an interrupt being triggered, or the OS and window manager, or the browser and DOM events, or HTTP or TLS or TCP or Ethernet or WiFi or LTE or routing and the tiers of network infrastructure or DNS or load balancing or proxies or web servers and tiers of API services or databases... It's can lead to some really fun technical conversation, follow up about how they learned the things they know and experiences they've had, and most of the time the interviewer learns something too.

robmccoll··on ChatGPT – The Revolutionary Bullshit Parrot
What I think a lot of people fail to consider (or are afraid to consider?) is the likelihood that we too are stochastic parrots.
robmccoll··on PageRank algorithm for graph databases
It's nearly a decade old at this point and probably not optimal even for the time, so there may be better approaches, but here's a few basic algorithms on SQLite. PageRank is at the bottom.

https://github.com/robmccoll/graphdb-testing/blob/master/tes...

The graph is just an indexed edge list with auxiliary tables to support algorithms as needed.

robmccoll··on Git security vulnerabilities announced
In this case it's really that the cost of determining if an overflow did occur or will occur on modern architectures is too high and the likelihood too low for it to be reasonable to perform the checks in most cases in native code. Might be different for interpreted languages depending on a lot of things (whether or not they even use integer arithmetic, whether or not they default to some arbitrary precision integers by default, etc.). If common architectures automatically interrupted on overflow rather than setting a flag at no additional cost, I'd think you'd see safety guarantees instantly.
robmccoll··on Hyperview: Native mobile apps, as easy as creating a website
Cool - extend this to just be a new browser that supports Content-Type: text/html and Content-Type: text/hyperview or something rendering either using a Web View or a Hyperview. Allow links between Hyperview documents within and across domains. Add user-driver permissions per domain for native APIs. It's been time to have a better alternative to HTML/JS for building rich applications on the web that still fit as web technologies.
robmccoll··on Use a laptop as a 2nd display on Linux using FreeRDP
It's great. I run a desktop running Windows with WSL2 for Linux and a MacBook Pro beside it. With some combination of a shared mouse, keyboard, clipboard, SSH, and SSHFS / NFS the experience is pretty seamless.
robmccoll··on Apple introduces end-to-end encryption for backups
(Not an iMessage user) Does iMessage actually have a way to display the raw public key(s) locally associated with a contact and your public key(s)? Wondering if you can verify keys out of band or if you have to trust Apple to be the authority.
robmccoll··on I Taught ChatGPT to Invent a Language
But aren't most linguists trained similarly? Broad spectrum knowledge throughout their elementary education and specifics in higher education? Mostly regurgitating things they have either memorized or been shown repeatedly.
robmccoll··on I Taught ChatGPT to Invent a Language
I have some level of concern that we have the same superpower.
robmccoll··on Go Style
Yep - return concrete types, but also make sure you have an assertion along the lines of:

    var _ IfaceType = &ConcreteType{}
Somewhere, else you risk not knowing that a change to ConcreteType broke is implementation of IfaceType in a way that you might not know about until a rare runtime code path is executed.
robmccoll··on Agile sucks for software development and I’m tired of pretending it doesn’t
No one will get far trying to have a debate here. Agile is both poorly and conflictingly well-defined and its adherents seem to lean on "no true Scotsman" defences when given an example of massive inefficiencies an organization that claims to do it. Whatever you are doing is "agile" if you are performing well and not if you aren't. Also the idea of some pure waterfall is nearly as much of a strawman as the ethereal agile. Measuring performance is also quite difficult. Is it meeting internal or external deadlines? Providing consistent and accurate estimates of time and effort? Providing software of sufficient quality regardless of those measures? Do what works for your team. Make changes if it isn't working.
robmccoll··on Section 230: Mend it, don’t end it (2020)
IANAL, but I'm not sure how the proposed change would have any effect. If the whole idea is to treat digital content platforms the same as distributors, distributors can stop carrying publishers and specific works on their own whims regardless of whether or not they are protected speech subject to the contracts that they have in place with those whose works they are distributing. The distributors don't have a government-backed monopoly that might come along with requirements that they adhere to laws that prevent the government limiting speech. You only have recourse if the contract in place between you and the platform stipulates the terms of distributing your content. It is my understanding that this law and the updated change don't specify that the government can compel you to produce specific speech, they specify that the government can't punish you for the speech of others that you distribute.

Am I missing important context? If someone can point to resources that would better explain this to me, I'd appreciate it.

robmccoll··on EPB launches America’s first community-wide 25 gig internet service
I don't think I have enough aggregate online disk bandwidth at home to store things are that speed, much less do I have it networked to do so. Wow.
robmccoll··on IFixit: Self Repair Program makes M1 MacBooks less repairable
I replaced the glued-down baggie-cell batteries in the laptop I'm currently using. It was a giant PITA, and I was very wary of burning my house down the entire time. It would absolutely be worth the cost difference to secure and protect the batteries in any other way.
robmccoll··on SQLite-HTTP: A SQLite extension for making HTTP requests
Go's HTTP client doesn't support pipelining in HTTP 1.1. It will do keep alive / socket re-use. HTTP 2+ have support for request multiplexing which Go supports. Your code appears to create a new client on each request, so I'm not sure if the underlying transport will be re-used or if any multiplexing will take place. I would be surprised if it is.
robmccoll··on Wikipedia has blocked editing ‘recession’ as people change definition
It would be a percentage thing. If I am the only competitor in the market, I can pass costs on to my consumers 100% because they can't really go anywhere else. I can also sneak in additional markup because prices are rising in other markets, labor costs, etc., so they probably won't notice. I've dominated the market, so opportunities to grow are more challenging (growing the market rather than taking market share). This provides an easier opportunity. End result is that my profit might increase.

If I have more competition, I might trade off taking some of the hit from my increased costs while still passing some on to the consumer to offer a lower overall price than my competition and potentially increase my market share, which ideally still leads to greater profits due to increased sales.

robmccoll··on TikTok videos leave teens thinking they have rare mental disorders (2021)
As an outsider, it seems like medical science would be particularly challenging. Underlying mechanisms for many common conditions aren't known or fully understood, but the collection of symptoms (syndrome) need to be treated now to improve quality of life. It would seem like this would lead to less strict and rigid systems of analysis and methodology out of necessity (working with the best information and analysis at hand, knowing that there are still many unknowns).

tl;dr - everyone's probably just doing the best they can.

robmccoll··on Google Launches Carbon, an Experimental Replacement for C++
I think Python's original take on kitchen sink was relatively small language with large "batteries included" standard library.
robmccoll··on Google Launches Carbon, an Experimental Replacement for C++
The more recent editions of C++ do seem to support this idea. Things are at least better than when the trade off was taking advantage of C++ features (and more C++ like) or performance (and more C-like C++). The problem that there are only a handful of people who could realistically claim to be experts in C++ has gotten worse over time as the language has expanded though. It's a language where you potentially have to train new C++ programmers that join your team in how your team uses C++.
robmccoll··on Google Launches Carbon, an Experimental Replacement for C++
I'm probably just biased, but to me the problem with modern C++ is its complexity. The mental model of the language, its syntax, and the amount of history / number of interfaces a programmer needs to be familiar with to be productive are all too large. Rust isn't any more complex, but it's not radically simpler either. Carbon doesn't look like it solves this problem. It would seem that creating a language that is expressive, performant, and small while still general purpose is quite a challenge.
robmccoll··on Atlassian is 20 years old and unprofitable
To me, the problem with many of Atlassian's products is that they aren't tools. They are platforms on which you can build the tool you need. They are way too configurable and flexible and as a result, you spend a lot of time managing the tool or organizing the information and configuration within it. Tools should serve a specific usage, behave predictably, help you use them correctly, then get out of the way.
robmccoll··on Enclave: An Unpickable Lock
Yeah I immediately thought of your work when I saw this. The key insight is the same, even if the implementation is different. Everything you do is fascinating by the way!
robmccoll··on LMN 3, an open source DAW in a box [video]
If you're looking to bring in more OSS and expand the sound synth pallet, you could bring in some of the Mutable Instruments code a la Arturia and the Microfreak. https://github.com/pichenettes/eurorack
robmccoll··on LMN 3, an open source DAW in a box [video]
This is great work! JUCE's licensing terms are a little confusing to me - do I correctly read that you can disregard the tier system as long as your usage complies with GPL3?
robmccoll··on Cache made consistent: Meta’s cache invalidation solution
Saying a problem isn't hard to solve because you have tools to analyze the correctness of your solution seems like a stretch.
robmccoll··on MongoDB Releases Queryable Encryption Preview
You could have a larger range than domain and throw in some noise. Exact match queries would need to become range queries that are de-noised at decryption.
robmccoll··on MongoDB Releases Queryable Encryption Preview
This is possible. The goal is that the server knows as little as possible, while the client has full information. It's order revealing encryption. The server side knows the ordering of the values, but doesn't know any specific value. When queried, it is always getting prefixes (or exact matches) following the same encryption scheme, so it can compare those to the corpus and select results since the query parameters fall into the same ordering. The server doesn't have access to the keys needed to generate query parameters, so in theory it would be difficult for the server to perform narrowing queries on its own. Over time the server could gather statistical results that may reveal more about the data it's holding. Also, these schemes may need to produce the same cipher text for the same input, so frequency distributions can be used to reveal information.
robmccoll··on The true cost of linked lists
Yeah, we should teach this to undergrads. If you want high performance for a dynamic list, you end up making a lot of tradeoffs with tricks like:

- Use blocks of multiple elements per actual list element that fit your cache line size. Blocks also have the benefit of potentially allowing SIMD processing of your data.

- Allocate blocks out of a vector or some other structure that reduces your actual number of allocation calls. Maintain a free list threaded through this vector.

- Tombstone list elements in their blocks on removal instead of repacking the entire list. This allows for fast deletions and fast insertions at specific locations (in that you can always insert a new block between existing blocks containing only a single element or get lucky and re-use a tombstoned slot).

Note that most of these optimizations trade some memory efficiency for speed. This is a common theme in optimization. Using more memory, but using it more intelligently such that you are potentially accessing less of it and accessing it sequentially where possible.

robmccoll··on Syncing files between browser and disk using Yjs and the File System Access API
This is a fantastic direction. It's interesting to me that you would rather revision control be implemented outside of this replication topology in something like git and that the interface between tools is strictly files rather than the CRDT events themselves. Integrating other applications in the CRDT event stream and maintaining the stream as the revision history would seem more efficient, less error-prone, and more open. Is it an eventual goal to expose something like this?
robmccoll··on Will Hare replace C? Or Rust? Or Zig? Or anything else?
I agree - Go's type system would be perhaps better described as strict. There are rarely cases in which conversion is implicit (not particularly unique to Go, but useful). Between types are aliases of those types? No. Between signed and unsigned? Of course not. Between string and []uint8? No. What about less precise to more precise? Nope. This can be a pain, but overall it avoids some classes of bugs present in languages like C (without getting strict about your compiler flags anyway) and allows you to use types to encode your problem in a way that prevents dumb mistakes.
← PreviousPage 5 of 14Next →