skysight-inc/HackerNews huggingface dataset:
I created a datalog engine a few years back called Dr. Lojekyll: https://www.petergoodman.me/docs/dr-lojekyll.pdf

It was pretty cool; you could stream in new facts to it over time and it would incrementally and differentially update itself. The key idea was that I wanted the introduction of ground facts to be messages that the database reads (e.g. off of a message bus), and I wanted the database to be able to publish its conclusions onto the same or other message buses. I also wanted to be able to delete ground facts, which meant it could publish withdrawals of the prior-published conclusions. A lot of it was inspired by Frank McSherry's work, although I didn't use timely or differential dataflow. In retrospect I probably should have!

This particular system isn't used anymore because we made a classic monotonicity mistake by making it the brain of a distributed system, and then having it publish and receive messages with a bunch of microservices. The internal consistency model of the datalog engine didn't extend out to the microservices, and the possibility of feedback loops in the system meant that the whole thing could lie to itself and diverge uncontrollably! Despite this particular application of the engine being a failure, the engine itself worked quite well and I hope to one day return to datalog.

I think what a lot of people miss with datalog, and what becomes apparent as you use it more, is just how unpredictable many engines can be with the execution behavior of rules. This is the same problem that you have with a database, where the query planner makes a bad choice or where you lack an index, and so performance is bad. But with datalog, the composition of rules that comes so naturally also tends to compound this issue, resulting in time spent trying to chase down weird performance things and doing spooky re-ordering of your clause bodies to try to appease whatever choices the engine makes.
This one too: https://www.facebook.com/100066178766049/videos
I like Carmack's approach to functions the best:

"If a function is only called from a single place, consider inlining it.

If a function is called from multiple places, see if it is possible to arrange for the work to be done in a single place, perhaps with flags, and inline that.

If there are multiple versions of a function, consider making a single function with more, possibly defaulted, parameters.

If the work is close to purely functional, with few references to global state, try to make it completely functional.

Try to use const on both parameters and functions when the function really must be used in multiple places.

Minimize control flow complexity and “area under ifs”, favoring consistent execution paths and times over “optimally” avoiding unnecessary work."

http://number-none.com/blow/blog/programming/2014/09/26/carm...
Either this is Ruby on Rails in all of its glory, or their infrastructure and ops need a lot of attention.

GitHub is definitely down more often in the last couple of years though. It's noticeable. Hope they figure it out.
I can't really take this article seriously when she links to a post that illustrates world events with a graphic worthy of this guy: https://i.kym-cdn.com/entries/icons/original/000/022/524/tum...
Next Week, the Supreme Court Could Destroy Everything Good About the Internet
2FA over SMS is the least secure option. It is free to use more secure options.
I like this simplified definition of sentience and consciousness: self-aware in space and time.

Right now, GPT is not - it can write that it is self-aware, but none of its actions indicate this. It seems likely that things like aircraft and cars are more sentient.

The term "Artificial Intelligence" makes it even more misleading. ML seems to replicate results and not the processes that output such results. So it a great variation of an acrylic portrait, with no understanding of acrylic, light, or even what humans are like underneath the skin.
That's exactly what I thought this would be. How to install an app that _doesn't_ have the "X" in jiggle mode.
It isn't the tool. It is how you use it
Totally understand. I know I am more productive at home and everyone on my team feels they are more productive from home too. However, as a team, I also know our productivity is subtly down in the last 3 years, because it falls on me to measure these things.

I don’t have hard data as to why, but right now my best guess as an explanation for my team is that we see ourselves as more productive when we are head down and cranking, and we are. But outside of those moments, we are not as productive, but we don’t perceive that we aren’t. Unfortunately my team are only heads down about 75% of the time and the productivity losses we feel are happening in that 25% of time and we just don’t notice.
>Do they think that a good citizen means a lobotomised workaholic high on sedatives?

Uh, yes. Most execs appear to think this.
For Linuxbrew, having packages installed under,

/home/linuxbrew/.linuxbrew

makes you wonder how much of the developer's mind is "works for me" instead of following more common sense conventions like at least put them under /usr/local or /opt instead of some special user folder in /home.
rad thanks. I wasn't planning any ai features, or datatypes -- but in toying with open ai it came about. I still need to add more inline methods to cast datatypes beyond people, companies, and locations. I'm working on attributes getting pulled out of notes too, so structured data is automatically created -- but not fully fleshed out yet. absolutely understand the need for local and encryption.
Make a note though that the immutable counterparts are not persistent, as the Clojure ones are.
Founder intuition is often just survivor's bias. We won't hear the stories of founders who have failed that often, considering that most fail.
Things are starting to work, but my actions are stuck in the queue.
Saturday morning, a weekend, is ostensibly worse than deploying on Friday evening.

I don’t see how any culture or geographical location can possibly make deploying outside of work hours reasonable.
Similar to efforts to reduce methane from cows instead of actually facing the fact that industrialized meat production is, y'know, really wasteful and bad for the environment (and us, given how bad eating too much red meat is)
Lol this is literally just different-looking cubicles. This is what was the norm before the open office concept took over.
While I agree that GH should focus on stability after adding features at what felt like a pretty breakneck speed over the past few years, lumping all of their incidents isn't helpful, nor is weird "math" that compares days to incidents.

For example, issues with repos themselves (pulling or pushing code) or Actions (which many folks use for their deployment pipelines) would be a lot worse than issues with Codespaces, in general.
This feels close to satire. How did WSJ neglect to mention that Facebook deliberately designed their main office building as the world's largest open office, a "soaring fishbowl, a contiguous 434,000 square feet on one floor" per their own coverage: https://archive.ph/XKaWJ
AMD and compute is one of these cases where no support is better than half assed support. You only get to waste so much of my time with a half working solution until I jump ship and blacklist your products forever.
This is a good thing. There's a constant struggle between people who want Linux to support their ancient hardware, and people who have to work with the kernel source regularly, and would like to speed up compile times and reduce git clone times. But it's undeniable that the balance needs to be struck, and old hardware needs to be deprecated at some point. I think the tipping point should be when 99% of people who need some feature will be perfectly fine with an outdated kernel. And, I think this case qualifies.
Text message two-factor authentication only available to Twitter Blue paid subs
There's no donkey or dumbass emoji :(
Hopefully someone reintroduces it as a loadable FUSE module for cases such as this.
Exactly. I wish I could consider a 7900 XTX or two for "enthusiast" level ML work at home (thinking open sourced GPT models, Stable Diffusion, etc), but the state of library support has me pricing out 3090s instead.

Sure, I could probably get ROCm going after a lot of tinkering and headaches but...that's not where I want to spend that effort.

Would happily be proven wrong on this by the way.
Considering that 'user generated content' is just a fancy term for the free labor of users that big content media sites appropriate to sell ads and keep the revenue for themselves, I'm not 100% certain that I would be terribly sad about the loss of Section 230 protections.

In other words, if the sites are going to profit off their users, they are clearly in a position of ownership of the content. They may not create it, but they sell it, as if they own it. Maybe they need to be reminded that they can't appropriate and profit off things they didn't create and then disclaim any responsibility for it.
Except having these discussions is really hard. It ends up being you against uncle bob and you are not gonna win that argument against a senior-er engineer.
Yup, pretty easy to just give the money, put a small plaque, and not put your name everywhere.
> and ideally don't cause unexpected side-effects etc., though when a function is 5-lines long, that's fairly easy to spot

Not easy to spot side effects if the 5 line function calls 999 other 5 line functions, which you have to do if you replace 1 function with 1000 functions. When people start to arbitrarily break up tightly coupled implementations into tiny functions you will get a much worse mess than if they just kept it as big as it was when they developed it.

Small functions are great, but forcing people to write small functions is not great. They are two different things.
I feel like the narrative would be switched, but the events would have played out the same.
One can try to make 'me things', and strive to make them good enough, or good, or even to their best extent, but not necessarily the best out there, at least always.
Thank you for actually providing a source. I swear I almost only see people say "source" when it's basically themselves!
There is a lot more to fail before the web worker that can be scaled indefinitely by putting more machines to respond behind a reverse proxy server.

Things like the database or random microservices that implement the death star architecture.
Discord handles emojis better than any other chat platform I've used; I think this is one of the main reasons people like to use it. Telegram's up there with Skype for being one of the absolute worst at handling them. I type :flushed: and it gives me smiling blushing face instead of :flushed:. I type :o (which has always meant surprised pikachu face, since before the surprised pikachu face was even a meme) and it gives me fearful face emoji. WHY? I respond with just an emoji, and it puts a huge distracting gimmicky animated emoji into the chat. Sure I can just disable them on my end, but other users are still going to see them as the default, which can lead to miscommunication, and also, I just don't want to be seen like that. Discord simply never steps on my toes like that, it works as intended. So many chat clients over the years have died by failing to understand that less is more.
> If a function is only called from a single place, consider inlining it.

A compiler should do this for you.

> If a function is called from multiple places, see if it is possible to arrange for the work to be done in a single place, perhaps with flags, and inline that.

This makes no sense to me.

> If there are multiple versions of a function, consider making a single function with more, possibly defaulted, parameters.

This can be useful, but only if it does not mess up code readability unless you are trying to squeeze your code into a cache.

> If the work is close to purely functional, with few references to global state, try to make it completely functional.

This makes very good sense, but it can be harder than it seems. One of the easiest ways (depending on how far down the call stack you are) you may just be able to pass the individual parts of that global state in as parameters.

> Try to use const on both parameters and functions when the function really must be used in multiple places.

Not all languages support this, but where they do this is good practice. In general: limiting scope and mutability is always an advantage.

> Minimize control flow complexity and “area under ifs”, favoring consistent execution paths and times over “optimally” avoiding unnecessary work.

Is also good advice.

In general you want to avoid nesting your ifs too deeply because at some point you lose track of what the local context is that got you there. Then it is usually better to break out a function and name it well so that that context is clear again. In general, naming things well is hard.
Haha, why would anyone be surprised to see that? Just take a look at other M$ products, pretty much the same.
I have, at two different companies, in fact, and 1000-line chubbers at a couple of others. The 5000 line functions weren't great, but they weren't that bad because the code was pretty straightforward, doing one thing after another top to bottom.

Over time they all got gradually broken down into smaller functions/methods.

(Disclaimer: I was not the original author of any of these.)
"Would you like to allow your toaster to make toast?"

"Please grant your refrigerator permission to store milk."
I would agree, purely on aesthetic grounds "1Password Park" sounds terrible. An example of how this can be done better would be something like the Institute for Contemporary Art in Richmond, VA [1]. The building itself is known as the "Markel Center" (Markel being the large insurance company that paid for it), and they have a small sign out front. I don't mind that at all. It helps that the name is a proper name, after the founder of the company, and it's not a well known B2C brand.

[1] https://goo.gl/maps/9Abqu6yRH5NygJJa7
I'd rather work with complex data than with complex code. Just structure the data as best as you can and then use functions that are simple to operate on that data. This will help keep code complexity down and makes it much, much easier to refactor because usually you'll be operating on a small subset of the data anyway.
I saw this yesterday (https://freeradical.zone/@tek/109876335075879967), although their status page was all green. I ran a command line like:

for i in (seq 10); git clone https://me:api_key@github.com/… foo; rm -rf foo; sleep 5; end

Out of those 10 clones, 2 of them succeeded, and 8 failed (evenly split between 2 different error messages). I opened a trouble ticket because our CI server was driving us nuts with alerts. The status was never anything but all green, though.
That 4chan meme picture doesn't make it look very trustworthy to be honest. Especially because the site asks for my data right after that. I'm sure I'm not going to give someone who likes 4chan memes my data.
Blog is addressing small segment of a book, you might still be missing a good learning. Maybe you can scrim some chapters here:
https://dev.to/thawkin3/in-defense-of-clean-code-100-pieces-...
What modern utilities should be a standard part of a modern unixy distro?
I mean, that's literally just their job. It would be one thing if Github and its parent company had a history of treating developers and open source with kindness and respect for their work but..yeah.
Queues should be empty
> A compiler should do this for you.

Point of inlining is to make it explicit that it is an ad hoc implementation for that location, so you don't have to be afraid of adding more stuff in it just to solve a local problem.
That simply overdoing it. 50 line functions are fine, 100 line functions can be useful. 5000 line functions should be an exception and 5 line functions can be useful if you can still give them a clear name and they end up being either re-used or are internal. If you start exporting 100's of functions you may want to re-evaluate the way you are interfacing your modules.
I generally liked APoSD.

I liked its notion of symptoms of complex code.

I liked its framing of complexity as related to dependencies involved in calling some function. -- If a function has more parameters than it really needs (too many dependencies), or a function has fewer parameters than it actually needs, then it's more complicated to work with than it needs to be (its actual dependencies are obscure). -- I liked its emphasis on "interface" is "what you need to know to use the code", as opposed to implementation details.

I liked the suggestion of "writing documentation before the implementation" as a way of coming up with a clean interface; although I found it bizarre that this logic didn't carry across to "write some tests before the implementation".
AI is pushing humans to do better. I remember about week ago Paul Graham tweeted that if you couldn't write a better novel than an AI then you need to seriously improve (paraphrasing).
I can totally empathize and truly hope you are enveloped within a pro-marijuana community to shut your mind off at night.
I did some reading on this a while back, since I was also morbidly interested, and I believe that they said they found lots of evidence of shoes because they contained the only material that the sea life around them wouldn't eat

Unfortunately, did some quick looking up right now to confirm, and it looks like it's theorized that the shoes were more from luggage that was blown out. But any human body parts would definitely have been long consumed or dissolved by now
> Our method discovers a simple and effective optimization algorithm, Lion (EvoLved Sign Momentum).

Come on now
It's kind of sad that I (and probably others) look back fondly at the era of cubicles as preferable to the current trends. With the caveat that there are some cubical farms (I'm looking at you, Intel) that barely different from open-plan offices with individual desk, some jobs I worked back in the day gave each person a relatively roomy and well-appointed individual cubicle. One place I had plenty of surface space in an L shape, multiple lockable storage areas, and even a small coat closet.
The idea for the grugjak image comes from the origin of the "grug" meme itself -- https://grugbrain.dev
Yeah, but read the very top of that post for his updated thoughts. The problem with manually inlining large functions is that they make code impossible to follow or reason about, which over time means that they turn into spaghetti code because people get lazy about reusing pieces from random other places in the same function.

His later addendum is important not to omit, because this is really the key to more reliable code:

> The real enemy addressed by inlining is unexpected dependency and mutation of state, which functional programming solves more directly and completely. However, if you are going to make a lot of state changes, having them all happen inline does have advantages; you should be made constantly aware of the full horror of what you are doing. When it gets to be too much to take, figure out how to factor blocks out into pure functions (and don.t let them slide back into impurity!).
Supporting uninstallation by restricting applications to a sandbox that can be cleaned up == locking down
Easily solved with a comment and that frees you up from using it in more than one place if you ever feel like it. Inlining is a very low level implementation detail, I think making that explicit is something that you only want to do if you are breaking out the function for clarity and to be able to name it when it only lives in a single location. A bit like an assembly macro.
Co-working spaces should take note
> So tired of these projects I could make in a few hours

"But you didn't, did you?" --Damien Hirst
The most obvious case is if the current production deployment is severely broken, in which case a weekend deploy may simply be the best of bad options.

Obviously that points to larger problems though.
Ah, so people that have fulfilling social lives outside of work and don’t need to fill that void with people they have to work with are “reclusive quiet quitters”. Sure. I don’t see how people described by yourself as “great workers” are simultaneously quitters, but you’ve got it figured out I guess.
I'm working in a space related nonprofit. The marketing of many startups in the field is quite problematic.

I'm biased thought because I prefer to communicate projects that have reached some maturity, but I have to admit that not seeking investor funding may allow such a thing.

One may argue that seeking investor funding may play a role to exaggerate your operations, but on the other hand this investors could and should seek better understanding of the technological and operational challeges involved.
My thoughts exactly. Facebook was the pioneer in the "Hey, everyone loves open office spaces! We can all collaborate!" bandwagon, to the point where other companies started going more towards that route years ago because "Big Silicon Valley companies are doing it!"

Yes, I speak from bitter experience.
And so everyone schedules there new job interviews on Monday and Friday
Vancouver hospital patient loses Netflix access due to password crackdown
> In 1999, investors from SFX Entertainment, along with co-founder G. Michael Harris and Arnie Geller, led a takeover and ousting of George Tulloch and the company's attorney.[23] Geller was installed as President and CEO of the company and Harris was installed as Chief Operating Officer as well as Secretary of RMS Titanic, Inc. They fired all other officers and directors and were the only two remaining directors.[24] John Joslyn was a small shareholder and took part in the takeover of the company in 1999.[25] Tulloch sued and was awarded $2.5 million in damages.[26] The abrupt takeover alarmed the governments of the U.K., France, Canada, and the U.S., especially when one of the insurgent investors was quoted as saying the new management was intent on cutting into Titanic's hull to recover more treasures and gain increased profits.
Sure, and my comment doesn't exclude it. I wonder what's truly the weakest link.
line noise much? man, that example is not pretty
It can be a good thing to wait a minor version or two before upgrading to the latest major version. There's much more confidence in the release that way, some companies even have a policy along those lines.
I see a lot of hate for GitHub after Microsoft, but there were many big improvement that I think outweigh some instability, especially for smaller companies or open source projects. Free private repos and free GitHub actions. The UI is also pretty nice and clean. I think GitHub is still one of the best options to host your code.
Not sure what a comment would solve. The point is that if you are making an ugly implementation for some reason, then inlining that is the right choice, breaking it out into a function that can only safely be called in that exact spot is by far the worst technical debt you can create. If you have a pile of shit then don't put it on a fan and spread it all over the room, isolate it so you know where it is and other parts can ignore it easily.
Should’ve slacked off more during wfh in the pandemic.
At work, the closest thing to approaching a working Cone of Silence ("Get Smart" reference) for me are a pair of AirPods Pro 2. I'm literally in my own world when I'm working in an open-plan office.

My level of annoyance went down significantly since I got them.

Bose QCs work too but they're not the most portable things in the world.
I would prefer if they just steal the right amount of money from me in the first place and leave me alone