There are a bunch of these topics that everyone feels qualified to say something about. Consciousness, intelligence, education methods, nutrition, men vs women, economic systems etc.
It's a very emotional topic because people feel their self image threatened. It's a topic related to what is the meaning of being human. Yeah sure it should be a separate question, but emotionally it is connected to it in a deep level. The prospect of job replacement and social transformation is quite a threatening one.
So I'm somewhat understanding of this. It's not merely an academic topic, because these things will be adopted in the real world among real people. So you can't simply make everyone shut up who is an outsider or just heard about this stuff incidentally in the news and has superficial points to make.
What i take away is the simplicity and scaling behavior. The ML field often sees an increase in module complexity to reach higher scores, and then a breakthrough where a simple model performs on-par with the most complex. That such a "simple" architecture works this well on its own, means we can potentially add back the complexity again to reach further. Can we add back MSA now? where will that take us?
My rough understanding of field is that a "rough" generative model makes a bunch of decent guesses, and more formal "verifiers" ensure they abide by the laws of physics and geometry. The AI reduce the unfathomably large search-space so the expensive simulation doesn't need to do so much wasted work on dead-ends. If the guessing network improves, then the whole process speeds up.
- I'm recalling the increasingly complex transfer functions in redcurrant networks,
- The deep pre-processing chains before skip forward layers.
- The complex normalization objectives before Relu.
- The convoluted multi-objective GAN networks before diffusion.
- The complex multi-pass models before full-convolution networks.
So basically, i'm very excited by this. Not because this itself is an optimal architecture, but precisely because it isn't!
This is something I've always wanted to write about, and I imagine that someday I'll end up with a long article, but basically, it's the idea that the internet used to be offline by default, and now it's online by default.
People used to be offline by default. You had to “connect to the internet.” Open MSN, go into forums and check the latest unread messages, come back from a concert and manually upload the photos to your Fotolog or wherever. Now it's the opposite. We are online by default. The expectation is that we're always connected and respond quickly. Going to a sports event or a concert? You have to post a story to Instagram from that very place, not when you get home. Someone sends you an email or a WhatsApp message? You’re expected to reply as soon as possible.
That’s what I miss most about the internet—the idea and the feeling that I would go online when I wanted to, not that I lived inside the internet 24/7.
I was at Lighthaven that week. The weekend-long LessOnline event Scott references opened what LightHaven termed "Festival Season", with a summer camp organised for the following 5 week days, and a prediction market & forecasting conference called Manifest the following weekend.
I didn't attend LessOnline since I'm not active on LessWrong nor identify as a rationalist - but I did attended a GPU programming course in the "summer camp" portion of the week, and the Manifest conference (my primary interest).
My experience generally aligns with Scott's view, the community is friendly and welcoming, but I had one strange encounter. There was some time allocated to meet with other attendees at Manifest who resided in the same part of the world (not the bay area). I ended up surrounded by a group of 5-6 folks who appeared to be friends already, had been a part of the Rationalist movement for a few years, and had attended LessOnline the previous weekend. They spent most of the hour critiquing and comparing their "quality of conversations" at LessOnline with the less Rationalist-y, more prediction market & trading focused Manifest event. Completely unaware or unwelcoming of my presence as an outsider, they essentially came to the conclusion that a lot of the Manifest crowd were dummies and were - on average - "more wrong" than themselves. It was all very strange, cult-y, pseudo-intellectual, and lacking in self-awareness.
All that said, the experience at Summer Camp and Manifest was a net positive, but there is some credence to sneers aimed at the Rationalist community.
It's the most high-influence, low-exposure essay I've ever read. As far as I'm concerned, this dude is a silent prescient genius working quietly for DARPA, and I had a sneak peak into future science when I read it. It's affected my thinking and trajectory for the past 8 years
I don't believe the document does a great job in explaining what is otherwise a very simple idea (assuming I understood it well):
1. It creates a bitmap where each bit is a pixel in the image, if from frame 0 to frame 1 a given pixel changed, the corresponding bit is 1, otherwise it is 0.
2. All the 1s are added to the bloom filter, hashing their offsets. Now the bloom filter will be positive for all such indexes plus a percentage of false positive indexes.
3. We query the bloom filter to see all the indexes that are positive, and for all such pixels we store the raw pixel data of what changed. So we can reconstruct the next frame easily.
You can think at this like as storing the delta between two frames as: x,y,r,g,b of all the pixels that changed, but compressing a lot the x,y part at the cost of storing a bit more r,g,b than needed.
I have the feeling that since the pixels that changes from frame 0 to frame 1 are often similar (in their location) to what will change from frame 1 to frame 2, there is the possibility of further compressing that as well, by setting the right flags in the next frame and storing verbatim the only offsets that changed in addition to the previous or alike.
MDX & claude are remarkably useful for expressing ideas. You could turn this into a little web app and it would instantly be better than any word processor ever created.
Stories like this are fun and I think they resonate well with a lot of people, but unfortunately the details are actively harmful cynicism that ignore fact that would ruin the narrative.
Look around San Francisco today. What has changed recently?
Crime is way down, lower than it has been in 15 years.
Homelessness is down, lower than the past 4 years.
Did tech companies decide to start paying more taxes? Did the city start spending more? No, the actual cause is boring and simple, but makes anti-establishment folks very uncomfortable.
The truth is that our government started operating more effectively, intentionally trying to solve problems that it previously pretended were insoluble. This change was instigated by a relatively small number of rich people where were fed up and decided to and spend their own money to fix the city.
Some other nitpicks I have with the sentiment expressed in the article:
* Police and firefighters in SF make more on average than tech workers. Is that a source of injustice? Or is unequal pay more complicated? Is inequality only bad when the groups benefitting are aesthetically undesirable to you?
* SF remains one of the highest tax cities in the country, and is the highest in the Bay Area. At the margin, businesses are leaving (including Twitter, mentioned in the article). Raising more taxes on these businesses seems unlikely to increase revenue long term.
* We spent more per resident on most services than nearly every other city in the country. Aren't you curious why that is, and doesn't it seem like understanding that problem would lead to insights more interesting than "tech bad"?
Lambda calculus is about template substitution. It is the abstract mathematics of substituting templates into other templates. Alonzo Church got interested in this when he realized that it had numbers,
type NumF = <X>(f: (x: X) => X) => (x: X) => X
const zero: NumF = f => x => x
const one: NumF = f => x => f(x)
const two: NumF = f => x => f(f(x))
Addition is not too hard to define, multiplication is actually just function composition, and decrement is an unexpected motherf$@&er. To understand this last point, it may help to understand that this encoding of numbers is basically zero as [], one as [null], two as [null, null], etc and you are trying to use Array.prototype.reduce to compute the array with one fewer element. So you can do it with a (last, curr) pair or a null initial value, you have to know what those look like in the lambda calculus to translate,
// predecessor and successor
const succ = n => f => x => n(f(x))
// Maybe fns: in λ-calc you'd uncurry
type MaybeF<x> = <z>(ifNil: z, ifJust: (x: x) => z) => z
const nil: MaybeF<any> = (ifNil, _ifJust) => ifNil
function just<x>(x: x): MaybeF<x> {
return (_ifNil, ifJust) => ifJust(x);
}
const pred = n =>
n(maybe_n => maybe_n(just(zero), k => just(succ(k))))(nil)
Now you asked for a technique to remember the Y combinator. The basic thing to remember is the infinite template substitution discovered by Haskell Curry,
(f => f(f))(f => f(f))
Forgetting everything you know about programming languages, and just thinking about template substitution, this is a template on the left, being substituted with a value on the right, and the reason it's an infinite loop is that after the substitution you get the exact same expression that you had before the substitution. [On the right we could have also written g => g(g) if that helps, the two variables are defined in separate scopes and only happen to have the same name f to make it clearer that this will loop infinitely if you try to eagerly evaluate it.]
Terms like this, were why Curry wanted a type theory. He immediately understood that this was kind of a weird expression because if you tried to express the idea of f(f) it was secretly holding on to a sort of paradox of self-reference or an infinity or whatever you want to call it. It is a function type which takes only the same function type as an argument, and returns God-knows-what. If you just forbid self-reference in the typing judgments, you don't get this sort of weird f(f) pathology.
So if you are remembering f(f) being somehow the key to the Y combinator, then you immediately see that you can kind of step it by not immediately evaluating it,
const Q = (f => () => f(f))(f => () => f(f))
so as a matter of algebra Q() = Q although a programming language struggles to prove equality between functions so as a matter of programming that might not be equal. So this is a function you can call Q()()()() and it's just infinitely callable without producing any other values.
But why () =>, why not x => ? Well, you can introduce that but Q will just ignore it, it doesn't know what to do with that. So you need to write f(f)(x) to plumb it through to do something.
Note briefly that there IS a difference between f(f) and x => f(f)(x). The latter delays execution of f(f) until needed and so is still stepped, the former is an infinite loop.
And the last thing is that you need to hand this internal function to someone else, some decider, to decide when to call the recursion. This leads to the full form,
Like most human endeavors where a technology is coming of age, there was a full aviation industry of hobbyists and nascent entrepreneurs. Most of them were little known by outsiders and on occasion some of them were put in the public spotlight because they had an interesting success or a whimsical failure.
Just take a look at the L'Aerophile gazette that started on the late 1800s. Similarly to computers, it's like reading the early editions of Byte magazine. There was a profuse number of people and small businesses from all over the world looking for collaboration with different goals in mind, selling their products and exchanging, stealing and improving on ideas of each other:
Adding 1 day still works the same with respect to civil time but the offset is wrong since it doesn't account for the DST change. And adding 24 hours leads to a different result as well. This is one of the reasons why RFC 9557 is so important for serializing zoned datetimes when you want your arithmetic to be DST safe. Previously, to get this right, you had to include a time zone out of band somehow along with your RFC 3339 timestamp.
wanted this but didn't want to run another app when I'm already running SwiftBar--here is a version suitable for use with SwiftBar/xbar/etc. (error handling left as an exercise for the reader):
#!/usr/bin/env node
var Ls = require('lightstreamer-client-node');
var sub1 = new Ls.Subscription("MERGE",["NODE3000005"],["Value", "Status", "TimeStamp"]);
sub1.addListener({
onItemUpdate: function(obj) {
const percentage = obj.getValue('Value') + '%';
console.log(`${percentage} `);
process.exit(0);
}
});
var client = new Ls.LightstreamerClient("http://push.lightstreamer.com","ISSLIVE");
client.connect();
client.subscribe(sub1);
"I don't understand most of the technical details of Apple's blog post"
I do:
- Client side vectorization: the photo is processed locally, preparing a non-reversible vector representation before sending (think semantic hash).
- Differential privacy: a decent amount of noise is added the the vector before sending it. Enough to make it impossible to reverse lookup the vector. The noise level here is ε = 0.8, which is quite good privacy.
- OHTTP relay: it's sent through a 3rd party so Apple never knows your IP address. The contents are encrypted so the 3rd party never doesn't learn anything either (some risk of exposing "IP X is an apple photos user", but nothing about the content of the library).
- Homomorphic encryption: The lookup work is performed on server with encrypted data. Apple can't decrypt the vector contents, or response contents. Only the client can decrypt the result of the lookup.
This is what a good privacy story looks like. Multiple levels of privacy security, when any one of the latter 3 should be enough alone to protect privacy.
"It ought to be up to the individual user to decide their own tolerance for the risk of privacy violations." -> The author themselves looks to be an Apple security researcher, and are saying they can't make an informed choice here.
I'm not sure what the right call is here. But the conclusion "Thus, the only way to guarantee computing privacy is to not send data off the device." isn't true. There are other tools to provide privacy (DP, homomorphic encryption), while also using services. They are immensely complicated, and user's can't realistically evaluate risk. But if you want features that require larger-than-disk datasets, or frequently changing content, you need tools like this.
That's not the intention of zero-trust. As others have said, it's about authenticating the user and associated privilege, not the machine itself. Simply put, zero trust means machines on the intranet must undergo a user-centric authentication and authorization step prior to accessing any resource. Additionally, once authenticated, a distinct secure channel can be established between the specific endpoint and the resource that cannot be observed or manipulated by others on the same network.
Badass on the visualization side. The multiple emitter portion and the end of the scroll reminded me of https://apenwarr.ca/beamlab/ which demonstrates beamforming (adjusting the phase of adjacent transmitters to focus power towards a specific receiver). To play with this one the "easiest" way to see what's going on is go to the right hand menu, unclick 3 so you just have 2 transmitters, click the "r" button, and then click or click and drag to see how the beam gets optimized (you can see some stats about the received power gain in the righthand side).
While this has to be the most fun to watch demonstration I've seen, something like the free tier of Hamina will likely be many times more useful to those wanting to optimize home Wi-Fi layout https://www.hamina.com/planner. The downside being they force you to make an account whereas this one lets you use it locally with the power of your own browser. The upside being Hamina gives multiple distilled views of the simulation as focused on common Wi-Fi statistics + features and less focus on displaying the wave simulation itself.
I love food and I love eating. Some of the most interesting dishes are vegetarian because you have to work that much harder to bring a dish together. That really excites the chef/epicurean in me.
And then you can just get a good quality slab of meat, give it a good char and sprinkle some salt on it and it'll stand on its own as basically a whole meal.
I think meat could 10-50x in price and I'll still find a way to eat it or I'll venture off into the wilderness and hunt it myself. No one could convince me otherwise - there's really nothing like catching your fish and cooking it over an open fire to round a day spent in the outdoors...
Gathering some nuts and fruit and blending soybeans to make tofu just doesn't have the same appeal to me... Even though wild fruit really are delicious and my friends stories of eating wild durian really inspire me to brave the sweat (and creepy crawlies and snakes) and venture off into the jungle
Like making anything last, don't operate at the limits of its envelope.
* Limit max temperatures
* Reduce maximum currents in and out
* For lithium batteries, limit peak charge to 3.92V, do *not* charge to over 4.1V or 30degC
I can't find the specific research study, but NASA did a study that last I read was going on for over 30 years with a neglible drop in capacity by only operating in the flat portion of the charge/discharge curve. The result is that properly speccd battery packs (probably > 1.5x most battery packs) can last indefinitely. For my cordless tools, I get the largest modules I can (5Ah). I have a single slim 2Ah module for fitting in tight spots.
*edit, when using a cheap intermittent high current device, like a hand vacuum, apply a duty cycle, like 30 seconds on, 10-30 seconds off to prevent the internal battery pack from getting too hot. These kinds of consumer goods have the smallest battery pack that will outlast the warranty.
I really wish battery charge profiles were codified in QR codes on the modules themselves (besides existing on an I2C bus).
I just released a plugin for my LLM command-line tool that adds support for the new Claude 3 models:
pipx install llm
llm install llm-claude-3
llm keys set claude
# paste Anthropic API key here
llm -m claude-3-opus '3 fun facts about pelicans'
llm -m claude-3-opus '3 surprising facts about walruses'
In the grand scheme, these are remarkably unsophisticated devices. It's almost a meme in RF circles to excitedly buy one and then immediately realize it's just a Girl Tech IM-me with NFC.
If you want to do real damage there are portable SDRs that can jam GPS and transmit just about any arbitrary radio signal from DC to 6GHz for less than $500. This is a mildly powerful toy that has a large, intelligent and curious community around it.
The reality is RF stuff is wildly under-explored right now outside of military spaces. On the consumer side I'd guess we're somewhere around the early 2000s internet in terms of security posture. It's probably best to consider the flipper community to be a gift of minimally destructive pentesters relative to what they could be if someone wanted to actually dish out real electronic warfare.
For anybody that's curious, the IP-Foo [0] browser extension puts a little 4/6 icon in the address bar to make it clear at a glance which dialect you're speaking for $currentWebPage
Morality and legality aside, there's a substantive difference between use of content and use of a model. Pretraining a GPT 4-class model from raw data requires trillions of tokens and millions of dollars in compute, whereas distilling a model using GPT 4's output requires orders of magnitude less data. Add to that the fact that OpenAI is probably subsidizing compute at their current per-token cost, and it's clearly unsustainable.
The morality of training on internet-scale text data is another discussion, but I would point out that this has been standard practice since the advent of the internet, both for training smaller models and for fueling large tech companies such as Google. Broadly speaking, there is nothing wrong with mere consumption. What gets both morally and legally more complex is production - how much are you allowed to synthesize from the training data? And that is a fair question.
Not surprising, the pipe you've created doesn't transport any of the data you've echoed.
(echo red; echo green 1>&2) | echo blue
This creates two subshells separated by the pipe | symbol.
A subshell is a child process of the current shell, and as such it inherits important properties of the current shell, notably including the open file descriptor table.
Since they are child processes, both subshells run concurrently, while their parent shell will simply wait() for all child processes to terminate. The order in which the childs get to run is to a large extent unpredictable, on a multi-core system they may run literally at the same time.
Now, before the subshells get to process their actual tasks, file redirections have to be performed. The left subshell gets its stdout redirected to the write end of the kernel pipe object that is "created" by the pipe symbol. Likewise, the right subshell gets stdin redirected to the read end of the pipe object.
The first subshell contains two processes (red and green) that run in sequence (";"). "Red" is indeed printed to stdout and thus (because of the redirection) sent to the pipe. However, nothing is ever read out of the pipe: The only process that is connected to the read end of the pipe ("echo blue") never reads anything, it is output only.
Unlike "echo red", "echo green >&2" doesn't have stdout connected to the pipe. Its stdout is redirected to whatever stderr is connected to. Here is the explanation what ">&2" (or equivalently, "1>&2") means: For the execution of "echo green", make stdout (1) point to the same object that stderr (2) points to. You can imagine it as being a simple assignment: fd[1] = fd[2].
For "echo blue", stdout isn't explicitly redirected, so it gets run with stdout set to whatever it inherited from its parent shell, which is (probably) your terminal.
Seeing that both "echo green" and "echo blue" write directly to the same file (again, probably your terminal) we have a race -- who wins is basically a question of who gets scheduled to run first. For one reason or other, it seems that blue is more likely to win on your system. It might be due to the fact that the left subshell needs to finish the "echo red" first, which does print to the pipe, and that might introduce a delay / a yield, or such.
My recent / favorite stack is Hugo, built by a Lambda function on git merge to the master branch.
I merge a change to master. Webhook triggers. Lambda builds the static site from a fixed version (for consistency) of Hugo (static site generator) and pushes the files to a CloudFront / S3 Website.
I can revisit my site after a year of non-maintenance and can add something without worrying about version changes breaking the site.. I don't even need any special software -- a text editor and git.
(For Rapid development, I generally run Hugo locally, but I can do a typo or link update from any computer very quickly)
- Sensodyne Repair and Protect contains 'NovaMin' (possibly only in some markets; check the ingredients!)
- NovaMin is the brand name for calcium sodium phosphosilicate
- It reacts with saliva to form a physical layer of hydroxyapatite on your teeth
- This layer blocks the tubules that trigger pain from temperature and such
- It also supports remineralization (how exactly?)