• 0 Posts
  • 27 Comments
Joined 3 years ago
cake
Cake day: June 14th, 2023

help-circle

  • GPT Researcher is a research agent, just one of many AI tools.

    I think the idea is that these tools let users configure mcp servers, and because mcp doesn’t necessarily use the network but can also just mean directly spawning a process, users can get the tool to execute arbitrary commands (possibly circumventing some kind of protection).

    This is all fine if you’re doing this yourself on your computer, but it’s not if you’re hosting one of these tools for others who you didn’t expect to be able to run commands on your server, or if the tool can be made to do this by hostile input (e.g. a web page the tool is reading while doing a task).



  • Swift is a modern language that offers good performance paired with a lot of safety features you’d otherwise go to Rust for (type safety, memory safety, concurrency safety,… although memory safety based on ARC is slower than Rust’s approach, and Swift makes it easier to disable safety features). Personally I like it more than Rust because the syntax is a bit cleaner and it has exceptions.

    The problem is, using it on e.g. Linux is a completely different experience from using it on Apple platforms and it doesn’t really transfer over. Apple devs will use Xcode and all the Apple tooling and will get used to Apple APIs. On Linux you don’t have Xcode, you rely more on Swift Package Manager for dependencies than on Apple platforms, you suddenly have to learn what part of the libraries you’ve been using are Swift standard library and what parts are Apple only or are from the Objective C runtime that’s not used on Linux, and the ecosystem is much smaller.

    A lot of things that also mean that code written for Apple doesn’t often work on Linux unchanged, not because of Swift as such, but e.g. before Swift had Regex you’d use the one from Objective C, which just works on Apple, but isn’t there on Linux.

    I haven’t tried it for Android development but I imagine it’ll have similar issues.







  • You don’t have to be the first person. I joined a startup a long time ago as a regular engineer and they made me team lead within a year. Startups generally move a bit faster and a lot more chaotically. Especially when they’re growing fast. You do have to be good but having a vision also helps.

    I stuck with them through acquisitions etc. and everything slowed down a lot. Should have gotten out of the large corporation life earlier tbh.






  • In Rust you’re kind of stuck with it, but at the end of the day combined return types are just syntactic sugar for something a lot of languages can do. Even in plain old C there’s a pattern where you pass pointers to your return and/or error variables. In many languages you can return structs or similar. In some I’d argue it looks nicer than having to write Result<>, e.g. in Python or in Swift you can just return a tuple by putting things in parentheses. (Of course you can also still use something more explicit too. But if every function returned (result, error) by default and every call was like result, error = fn(), I don’t think it’d be necessary.)

    However I don’t really know of any language where people prefer to use this over exceptions if exceptions are available. Even in C some people used to use setjmp/longjmp in macros to implement exceptions. Exceptions have their problems but people seem to overwhelmingly be in favor of them.

    Personally I like exceptions in languages that have some kind of built-in “finally” for functions. For example defer in Swift. You can have proper error handling for a lot less typing in many cases because passing through exceptions is fine if your defer blocks handle the cleanup. And if you do want to handle an exception, Swift also has optionals, and a try? that transparently converts a return value into an optional that’s nil when an exception was thrown, and a coalescing operator ??, which means you can catch exceptions and provide a default value on one line, instead of a 4-5 line try…catch/except block or an error checking conditional for every call.





  • I don’t understand how people can look at the insane progress gpt has made in the last 3 years and just arbitrarily decide that this is its maximum capability.

    So this is not entirely arbitrary, and probably part of it is also that they’re not just looking at the progress, but also at systemic issues.

    For example we know that larger models with more training material are more powerful. That’s probably the biggest contributing factor to the insane pace at which they’ve developed. But we’re also at a point where AI companies are saying they are running out of data. The models we have now are already trained on basically the entire open internet and a lot of non-public data too. Therefore we can’t expect their capabilities to scale with more data unless we find ways to get humans to generate more data. At the same time the quality of data on the open internet decreases because more of it is generated by AI.

    On the other hand, making them larger also has physical requirements, most of all power. We are already at a point where AI companies are buying nuclear power plants for their data centers. So scaling in this way is close to the limit too. Building new nuclear power plants takes ages.

    Another different thing is that LLMs can’t learn. They don’t have to be able to learn to be useful, obviously we can use the current ones just fine at least for some tasks. But nonetheless this is something that limits the progress that’s possible for them.

    And then there is the entire AI bubble thing. The economical side of things, where we have an entire circular economy based on the idea that companies like OpenAI can spend billions on data centers. But they are losing money. Pretty much none of the AI companies are profitable other than the ones that only provide the infrastructure. Right now investors are scared enough to miss out on AGI to continue investing but if they stopped, it would be over.

    And all this is super fragile. The current big players are all using the same approach. If one company makes that next step and finds a better approach than transformer LLMs, the others are toast. Or if some Chinese company makes a breakthrough with energy usage again. Or if there is a hardware breakthrough and the incentive to pay for hosted LLMs goes away. Basically even progress can pop the bubble because if we can all run AI that does a good enough job at home then the AI companies will never hit their revenue targets. And then the investment stops and companies that bleed billions every quarter without investors backing them can die very quickly.

    Personally I don’t think they will stop becoming better right now. Even if they do stop, I’m not convinced we understand them well enough to be unable to improve the ways in which we use them a bit more. But when people say that this is the peak, they’re looking at the bigger picture. They say that LLMs can’t get closer to human intelligence because fundamentally, we don’t have a way to make them learn, they say that the development model is not sustainable, and other reasons like that.