I find their critique compelling, particularly their emphasis on the disconnect between CoT’s algorithmic mimicry and true cognitive exploration. The authors illustrate this with examples from advanced mathematics, such as the "windmill problem" from the International Mathematics Olympiad, a puzzle whose solution eludes brute-force sequential thinking. These cases underscore the limits of a framework that relies on static datasets and rigid generative processes. CoT, as they demonstrate, falters not because it cannot generate solutions, but because it cannot conceive of them in ways that mirror human ingenuity.
As they say - "Superintelligence isn't about discovering new things; it's about discovering new ways to discover."
The referenced Apple blog post[1] is pretty clear on what this feature does, and I wish the author at lapcatsoftware (as well as folks here) would have read it too, instead of taking the blog post as-is.
Apple has implemented homomorphic encryption[2], which they can use to compute distance metrics such as cosine similarity without revealing the original query/embedding to the server. In the case of photos, an on-device model is first used to detect if a landmark may be possibly present in the image, and then sends an encrypted embedding[3] for the image region containing said landmark, which is evaluated on the server using HE techniques and then the encrypted results are sent back.
I'm sure someone will come along and say Apple does none of these things; in which case, said commenter should probably not use Apple devices since, there is no reason to trust the toggles for "Enhanced Visual Search", and perhaps more importantly, the one for "Advanced Data Protection" either. However, I rarely see any other major company researching ML and HE together, so that alone is a sufficient positive indicator in my eyes.
(It's interesting that this is also being downvoted. Please go ahead, I can't stop you :P but please also write the parts that you disagree with. Thank you.)
BSP is a technique for optimizing visibility calculations on convex level geometry. You're still making a 3D model and that's exactly what's stored as part of a .bsp file. So the point isn't BSP being outdated.
Just Trenchbroom and tools like it have more of a Minecraft creative mode simplicity to them, with click and drag snap to grid rapid prototyping of basic level geometry, and even more advanced geometry and details (including creating slopes and cylindrical structures, rafters, vents, general architectural details), than Blender's out of box generic UX presentation intended for all use cases of 3D design.
I genuinely think Kagi has led the way on this one. Simplicity is beautiful and effective, and Kagi has (IMHO) absolutely nailed it with their AI approach. It's one of those things that in hindsight seems obvious, which is a pretty good measure of how good an idea is IMHO.
Google could have done it and kind of tried, although they're AI sucks too much. I'm very surprised that OpenAI hasn't done this sooner as well. They're initial implementation of web search was sad. I don't mean to be super critical as I think generally OpenAI is very, very good at what they do, but they're initial browse the web was a giant hack that I would expect from an intern who isn't being given good guidance by their mentors.
Once mainstream engines start getting on par with Kagi, there's gonna be a massive wave of destruction and opportunity. I'm guessing there will be a lot of new pay walls popping up, and lots of access deals with the search engines. This will even further raise the barrier of entry for new search entrants, and will further fragment information access between the haves and have-nots.
I'm also cautiously optimistic though. We'll get there, but it's gonna be a bit shakey for a minute or two.
I have a big 49" wide screen monitor and sharing my screen in Google Meet was cumbersome because you can only share a window or the whole screen, but not a screen region.
So I wrote a small tool that uses the xrandr extension to mirror an area to a virtual monitor which then can be shared.
Nice improvements in boot speed. Perhaps a little blurb / intro / summary would be helpful to the post to help with understanding the achievements made.
Did the patches ever make it into Firecracker for booting FreeBSD as a guest? I looked back at the paper trail and it seemed like it may have stalled.
A recurring theme in so many startups I've seen inside is how the CEO in particular is extremely aloof with regards to presence. Sometimes that translates to aloofness for staff, but what more often happens is that when the CEO _does_ come in they expect other people to be there. So long as the alignment is good they don't care, but when it's not aligned, they just assume nobody is ever around and get real pissy about people showing up on time.
Fortunately the "good" ones are able to disassociate how much of that emotion is just them being lonely vs how much of it is actual synergy-seeking or whatever. The worst cases are people who get real tyranical, on top of just like... outright not showing up to do the actual day-to-day work that they are blockers on. A proper theory of the mind can often be quite absent.
My really glib take on this phenomenom is that a not-insignificant chunk of decision making for HR stuff is "make the CEO fill the tip-top of their
Maslovian pyramind". And to a lesser extent other executives who have decided that their job is their life.
Very annoying to listen to post-facto RTO arguments when you can feel the loneliness as the driving factor. Make a fun space, and make people's work schedules be loose enough to where they can actually relax in the space, and some people will show up! Or at the very least, give the CEO a fun side project to work on or something.
We face a number of challenges simply letting our paying customers change their search engine:
1. On iOS the list of allowed search engines is simply baked into OS, we have a fiddly extension that hooks outbound calls to /search and redirects them but I wish we didn't need to.
2. On Chrome, we use an extension to change the default search engine and enable search auto-complete etc, but Google has a policy that such an extension can do one thing and one thing only, and recently removed our extension on account of that [1]. We rebuilt it to meet their needs but had a lot of back-and-forth because we included 'search by image' on a context menu item and the first reviewer felt that was a bridge too far. You'll note that Chrome provides such a context menu item for Google Image search out of the box.
3. On Chrome for Linux, the default search engine API is not available, so Linux users have to configure it manually through a series of silly steps [2]. This is at least in keeping with most Linux experiences.
There are other issues, but I say all this to highlight how surprisingly difficult it is to change this setting in a practical, consumer friendly way. It is most certainly this difficult by design, that's a lot of revenue to protect.
Unfortunately the Python part of that is not open source but it was only a few lines of code - should be easy to recreate. That repo does contain a C library that does a similar thing.
You might just say "why not just run your program directly with the debugger?" and yeah that is better when you can do it, but I'm working with complicated silicon verification flows that are often several layers of Python and Make, followed by a simulator (e.g. Questa or VCS) that itself loads the library you want to debug. Very difficult to make debugging work through all those layers, but it's quite easy to write some code at the bottom of the stack that says to a debugger "I'm here, debug me!".
One thing to note is that it is impossible to strip types from TypeScript without a grammar of TypeScript. Stripping types is not a token-level operation, and the TypeScript grammar is changing all the time.
Consider for example: `foo < bar & baz > ( x )`. In TypeScript 1.5 this parsed as (foo<bar) & (baz > (x)) because bar&baz wasn’t a valid type expression yet. When the type intersection operator was added, the parse changed to foo<(bar & baz)>(x) which desugared to foo(x). I realise I’m going back in time here but it’s a nice simple example.
If you want to continue to use new TypeScript features you are going to need to keep compiling to JS, or else keep your node version up to date. For people who like to stick on node LTS releases this may be an unacceptable compromise.
I often wonder into which of these two categories I fall with my epaper calendars.
On the one hand, I’ve been working on this product for four years, put every free minute into it, and it still doesn’t make enough money for me to quit my job.
On the other hand, the product keeps getting better as I work on it, and I have now sold 500 of them.
But sometimes I feel like I can’t keep going like this. Two jobs and a family is just too much.
I think I should either quit my job and properly focus on it, relying on savings until the sales can support me. Or put the project into maintenance mode (I will keep the lights on for at least 10 years, no matter what).
It does support multiple pages but you can use just one.
It has a nifty feature in that you can divide the single file into virtual parts. They just have alternate backgrounds to tell them apart. And each virtual part can have a type for syntax highlighting (plain text, markdown or a programming language).
I've been using it for a few months now and it's my primary note taking / knowledge recording thing.
Even though it's web based, on Chrome you can save notes on disk so it works like a desktop app.
Each note is a plain text file so you can edit them in any text editor.
If you put notes on a shared drive (Dropbox, OneDrive, Google Drive etc.) you can work on notes on multiple computers.
In traditional databases, only the database engine has a scalable view of the data - that’s why you send SQL to it and stream back the response data set. With Datomic, the peer has the same level of read access as the transactor; it’s like the database comes to you.
In this read and update scenario, the peer will, at its leisure, read existing data and put together update data; some careful use of compare and set, or a custom transaction function, can ensure that the database has not changed between read and writes in such a way that the update is improper, when that is even a possibility - a rarity.
At scale, you want to minimize the amount of work the transactor must perform, since it so aggressively single threaded. Off loading work to the peer is amazingly effective.
Arrow JS is just ArrayBuffers underneath. You do want to amortize some operations to avoid unnecessary conversions. I.e. Arrow JS stores strings as UTF-8, but native JS strings are UTF-16 I believe.
Arrow is especially powerful across the WASM <--> JS boundary! In fact, I wrote a library to interpret Arrow from Wasm memory into JS without any copies [0]. (Motivating blog post [1])
I recently started using "Clear-Site-Data" and it's been a neat addition. I just create a single endpoint on my site or API domain and make a page or method that returns this header. There's all kinds of utility in having this.
This analogy works well when trying to describe how eBPF is used for network applications. The eBPF scripts are "packet shaders" - like a "pixel shaders" they are executed for every packet independently and can modify attributes and/or payload according to a certain algorithm.
I'm not sure if I'll migrate my existing function calling code I've been using with Claude to this...
I've been using a hand rolled cross-platform way of calling functions for hard coded workflows and autonomous agents across GPT, Claude and Gemini. It works for any sufficiently capable LLM model. And with a much more pleasant, ergonomic programming model which doesn't require defining the function definition again separately to the implementation.
Before Devon was released I started building a AI Software Engineer after reading the Google "Self-Discover Reasoning Structures" paper. I was always put off looking at the LangChain API so decided to quickly build a simple API that fit my design style. Once a repo is checked out, and its decided what files to edit, I delegate the code editing step to Aider. The runAgent loop updates the system prompt with the tool definitions which are auto-generated. The available tools can be updated at runtime. The system prompt tells the agents to respond in a particular format which is parsed for the next function call. The code ends up looking like:
export async function main() {
initWorkflowContext(workflowLLMs);
const systemPrompt = readFileSync('ai-system', 'utf-8');
const userPrompt = readFileSync('ai-in', 'utf-8'); //'Complete the JIRA issue: ABC-123'
const tools = new Toolbox();
tools.addTool('Jira', new Jira());
tools.addTool('GoogleCloud', new GoogleCloud());
tools.addTool('UtilFunctions', new UtilFunctions());
tools.addTool('FileSystem', getFileSystem());
tools.addTool('GitLabServer',new GitLabServer();
tools.addTool('CodeEditor', new CodeEditor());
tools.addTool('TypescriptTools', new TypescriptTools());
await runAgent(tools, userPrompt, systemPrompt);
}
@funcClass(__filename)
export class Jira {
/**
* Gets the description of a JIRA issue
* @param {string} issueId the issue id (e.g XYZ-123)
* @returns {Promise<string>} the issue description
*/
@func
@cacheRetry({scope: 'global', ttlSeconds: 60*10, retryable: isAxiosErrorRetryable })
async getJiraDescription(issueId: string): Promise<string> {
const response = await this.instance.get(`/issue/${issueId}`);
return response.data.fields.description;
}
}
New tools/functions can be added by simply adding the @func decorator to a class method. The coding use case is just the beginning of what it could be used for.
I'm busy finishing up a few pieces and then I'll put it out as open source shortly!
For those who don't already know, this is built on tree-sitter (https://tree-sitter.github.io/tree-sitter/) which does for parsing what LSP does for analysis. That is, it provides a standard interface for turning code into an AST and then making that AST available to clients like editors and diff tools. Instead of a neat tool like this having to support dozens of languages, it can just support tree-sitter and automatically work with anything that tree-sitter supports. And if you're developing a new language, you can create a tree-sitter parser for it, and now every tool that speaks tree-sitter knows how to support your language.
Those 2 massive innovations are leading to an explosion of tooling improvements like this. Now every editor, diff tool, or whatever can support dozens or hundreds of languages without having to duplicate all the work of every other similar tool. That's freaking amazing.
This is really amazing! I look forward to giving it a try. Kudos to the Go team and contributors.
Say what you will about the language itself, the Go stdlib is one of the most useful and pleasant standard libraries I've ever worked with. It gets better with every release, and great care is taken to make it featureful, performant and well documented. These days for most general things I rarely have the need to reach for an external package.
In strategic sysadmin and cybersecurity this is staple thinking, and a
useful part of what I teach now.
Problem for vigilant thinkers is the rewards, as explained in TFA,
are perverse.
People are content with technology to be magical. They don't see the
millions of people quietly repairing it and planning to keep it all
going smoothly.
To "bosses" cybersecurity only bring them problems, and cost them
money apparently doing nothing. The same for any defence force, until
you need it.
Did some nice interviews for international sysadmin day last summer
[1].
Additionally, here is a great talk on queuing theory and load shedding. One argument this talk makes is that autoscaling is not the silver bullet you think it is (similar to queues).
Thanks! The project consists basically out of two components, the runtime and the editor.
The runtime is mostly self-written, focusing most of my efforts. The editor on the other hand is built on `rete.js` (https://retejs.org/) and Angular. ReteJS is a really amazing node editor framework. While I customized almost everything that was possible, a lot of credit goes to them.
In hindsight, Angular might have been a little bit of overkill, but it's the framework I'm comfortable with, given my very limited web development experience.
For any shell command where a minor mistake has the potential of ruining your day, take a look at “try”, which will allow you to inspect the effects before running it against a live system: https://github.com/binpash/try
I'm not happy with any of the solutions to prevent a flash of undefined components. Has anyone given up on web components for that reason? Or is there a best practice for this?
As they say - "Superintelligence isn't about discovering new things; it's about discovering new ways to discover."