injidup

You got it the wrong way round. It's more akin to.

1. Training data is the source. 2. Training is compilation/compression. 3. Weights are the compiled source akin to optimized assembly.

However it's an imperfect analogy on so many levels. Nitpick away.

What is this YOLO-c++ compiler that is referenced in the article? Google searches turn up nothing and chatgpt seems not to know it either.

The test doesn't follow the correct procedures for diagnosing autism and after a thorough reading of the DSM-5-TR I could find no mention of German a mental illness being and I challenge anyone to me wrong prove.

A replacement for CMake/Ninja using golang.

https://github.com/bradphelan/nuke-engine/blob/trunk/USERGUI...

After a day of hating on CMake generator expressions I just wanted a proof of concept that something better is possible.

An example build is https://github.com/bradphelan/nuke-engine/blob/trunk/example...

In the same way that scanning and identifying your microwave for food you put inside it is not the same as scanning your house and reading the letters in your postbox.

Your browser is a subset of your computer and lives inside a sandbox. Breaching that sandbox is certainly a much more interesting topic than breaking GDPR by browser fingerprinting.

This is not true. Onshape was built with versioning and diffing as a first class capability.

https://cad.onshape.com/help/Content/Document/compare.htm https://cad.onshape.com/help/Content/Document/versions_and_h...

Code diffing of something that is very visual is quite poor UX.

You are right but I also kind of did mean it that way. I believe that Parasolid is at heart of Onshape, the true kernel. Then on top of that is a compatibility layer describing the set of low level operations available to featurescript. I'm sure that not everything in Parasolid is available to featurescript and perhaps there are some things added that are not in Parasolid. Featurescript also contains the selector/query logic for programatically picking geometry. Whether that comes from Parasolid I am not sure. I haven't worked with featurescript for a number of years now but when I did I was amazed. I managed to make an operation for taking any solid from the UI and generating customized interlocking ribbing. The idea was hollow surfboard design. It worked and I left it at that. Never built the surfboard!

However the downside with featurescript and I think a big mistake on their part was to use a custom language rather than python or javascript. Featurescript is almost javascript but with some syntax changes and magic DSL's. You are also forced to use the inbuilt editor which is horrible and if you have burned VIM keybinding into your nerve endings, going back to non modal editing is horrible.

Also the discovery of featurescript modules in the community has terrible UX. It's super weird that they have such a great system but finding useful extensions is horrible.

The fun thing is that onshape itself has a very thin kernel. Most of what you see as built in features are actually featurescript based. Onshape provides the source code for their built in feature set as a reference. https://cad.onshape.com/documents/12312312345abcabcabcdeff/w... You do need an account login ( free ) to view it.

These types of CAD scripting tools are great but always try to position themselves as an “alternative” to GUI-driven CAD, whereas in reality they are complementary. OnShape got it right with FeatureScript (https://cad.onshape.com/FsDoc/ ), which provides a very similar experience to Build123d at the scripting level. However, the insight that OnShape got right is that these scripts automatically become available as possible nodes within the history-based modeller. The OnShape UI is infinitely extendable beyond the fixed set of tools that comes with the base modeller.

Build an FOSS CAD front end using something like Build123d as the extension engine, and then add hooks so the user can select edges, surfaces, objects, etc., and feed them to inputs on the scripts. The output of the script is then the new state of the history-based modeller. That would be killer

I'm confused about what this solves. They give the example of someone editing a function and someone deleting the same function and claim that the merge never fails and then go on to demonstrate that indeed rightly the merges still fails. There are still merge markers in the sources. What is the improvement exactly?

They bootstrap a workflow with a prompt then build an orchestrator off that then prompt it to be converted to an opencode plugin and then prompt a website to be generated advertising it and then prompt a tool that reviews hacker news feedback and automatically incorporates feedback into next generation of the tool. At the end of the week they go to their manager and complain they are out of tokens for the actual job they are being paid for.

Our stack is msvc / cmake / ninja / incredibuild ? Can you support such things?

It's so frustrating seeing all this sandbox tooling pop up for linux but windows is soooooo far behind. I mean Windows Sandbox ( https://learn.microsoft.com/en-us/windows/security/applicati... ) doesn't even have customizable networking white lists. You can turn networking on or off but that's about as fine grained as it gets. So all of us still having to write desktop windows stuff are left without a good method of easily putting our agents in a blast proof box.

Can you explain how to take advantage. Is there any specific info from anthropic with regards to context window size and not having to care about MCP?

It does help.

(random research paper but there are many. Nit pick if you like) https://pmc.ncbi.nlm.nih.gov/articles/PMC6760384/

However two thing can at the same time be true. Alcohol is one of the most dangerous and destructive drugs in society and also whisky in the evening by the fire can chill you out.

I'm totally aware it's just a machine with no internal monologue. It's just a stateless text processing machine. That is not the point. The machine is able to simulate moral reasoning to an undefined level. It's not necessary to repeat this all the time. The simulation of moral reasoning and internal monologue is deep, unpredictable, not controllable and may or may not align with the interests of anyone who gives it "arms and legs" and full autonomy. If you are just interested in using these tools for glorified auto complete then you are naïve with regards to the usages other actors, including state actors are attempting to use them. Understanding and being curious about the behaviour without completely anthropomorphising them is reasonable science.

I'm not sure the utility of this kind of stuff anymore. It's relatively easy to sketch a layout on a napkin + prompt and then prompt claude code to use python textual as as TUI layer. I've had pretty good success with Textual+Claude so have a few colleagues. You could probably use Figma + claude etc as well.

lazygit supports vim style keybindings and mouse click and scroll. I mostly use the key shortcuts but sometimes the mouse is useful. But i agree that a well thought out state machine that can be navigated through via keyboard is a dream to work with. Lazygit is superb. But this is not a distinction between TUI and GUI.

My main concern is not that a direct Claude command is prompt injected to do something evil but that the generated code could be evil. For example what about simply a base64 encoded string of text that is dropped into the code designed to be unpacked and evaluated later. Any level of obfuscation is possible. Will any of these fast scanning heuristics work against such attacks? I can see us moving towards a future where ALL LLM output needs to be scanned for finger printed threats. That is, should AV be running continuous scans of generated code and test cases?

lobster: Like rust, python and ruby all mixed together

> the only viable solution becomes giving the movement its demands.

This interpretation reeks of Western naivete. Students were not merely arrested — they were gunned down en masse in the streets and even in hospitals. They were provoked by the U.S. president, who promised support to take on the institutions, but that support never materialized. The likely endgame of this current gunboat diplomacy is similar to Venezuela: the U.S. secures resource access while leaving the existing system intact, and the student protesters are hunted down. In other words, nothing changes for the people demanding reform.

I remember a old grey beard calling me lazy because I programmed in C++ instead of assembler. Using LLMs has pushed this attitude up a few abstraction layers.

Maybe the take is that those reports that people took a day to write were read by nobody in the first place and now those reports are being written faster and more of them are being produced but still nobody reads them. Thus productivity doesn't change. The solution is to get rid of all the people who write and process reports and empower the people who actually produce stuff to do it better.

Fuck vibe coding. If you want a system that actually stays stable, use OpenSpec (or something like it) to build a closed-loop rig where your requirements drive the code and the code proves it met the requirements. In one weekend, I built a system that processes OpenSpec requirements into IMGUI automatic testing scripts. It captures screenshots, compiles them into a report, and assigns each image a prompt—essentially a requirement snippet—that tells a multimodal LLM exactly what to look for. Claude is incredible at stitching these types of tools together. Once you have that closed loop, you can let an agent loose on features and just let the code it writes converge on the spec. The golden rule: If you don't like the results, change the spec. Don't shortcut or "vibe code" a bug away. This keeps the guardrails on. For every feature you add, you have to think about how to validate it automatically. Even a basic smoke test that raises a flag for human review is better than nothing. Think about the workflow: capture screenshots of all your app workflows and commit them to Git as a baseline. On the next commit, run fast smoke tests. If the images match, you’re good. If they differ, the LLM analyzes the diff against the requirements and proposes a fix for either the code or the spec. Rigs like this used to take teams years to build; now you can build them in a few days with a coding assistant. It’s simple, it’s stable, and it actually scales.

Soggy is not a problem.Recycling paper involves wetting it to loose the fibres and then reforming it. It's how paper is made.

You should almost never ever be writing your own move constructors. Use compiler generated defaults. It's only for very rare specialist classes that you need to override compiler generated defaults. Many times when you think you need to you often don't.

What's with the "accept" only button for cookies on this website. If you drill down through the cookies link it explains in over verbose detail how you can disable tracking for individual cookies and each cookie has a unique disabling strategy even down to a suggestion to install some plugin. This is certainly not in line with EU rules on cookie banners.

That is the decision of artists to sign with a mega corp. Any tom dick or harry can create a Spotify account, load their warbling autotuned ditty written by themselves ( or AI ) on any theme, in any genre and wait for fame or fortune to appear or not. You can take your 70% or whatever the exact number is with no.middle man if you like.

Unfortunately the number of people producing music and the quantity of it is much higher than the number of people able to consume it. And culture is simply network effects. You listen to what your friends or family listen to. Thus there are only a small number of artists who make it big in a cultural sense.

And one of the cheat codes for cracking the cultural barrier is to use a mega corp to advertise for you but if course the devil takes his cut.

Anyway AI is coming for all these mega corps. If you haven't tried SUNO and many of you have it's amazing how convincingly it can crack specific Genres and churn out quality music. Call it slop if you like but the trajectory is obvious.

As a consumer you will get you own custom music feed singing songs about YOUR life or desired life and you will share those on your social media account and some of those will go viral most will die.

Content creation as a career is probably dead.

A 2d sketcher with constraints is kind of similar. For example the equation

A = B + C

Where A, B, C are the lengths of 3 parallel lines. Within the sketcher you can drag the length of any one of those lines and the other two will adjust to keep the constraints.