allisdust

The answer lies in your question. I foresee consolidation in programming languages and frameworks with compact and well known ones edging out esoteric and niche ones. In a couple of years of time, I predict that there will be new languages specifically targeting LLMs that aren't as human readable but extremely compact similar to byte code (compactness is preferred due to context size limitation not fully going away).

So in a nutshell I feel like most things will be LLM generated with human focus mostly around systems boundary stitching with focus on extreme cases like quant and medical domains where human oversight might be needed.

I pity comments like this. Instead of trying to up skill to use the newest programming tools, you are setting yourself for failure.

Sonnet 3.5 digests close to 400k bytes of text and produces coherent code that works on the first try. If someone says its not working and they are a professional programmer, get ready to feel like you are hit by ton of bricks next year. The productivity boost is only going to accelerate and those who can't adopt will be left behind.

It does get paid in full at the maturity. It's just that the governments rollover the debt by selling new debt.

Like the other comments say, most likely the product owner describes his requirement in as much detail as possible and the phase-1 LLM will convert that to designs. Based on the feedback, it will be iterated and may be 3-4 designs selected for A/B testing.

The phase-2 LLM converts the designs to code in either react/flutter (both of which current LLMs are already quite good at) and deploy for a certain set of users. Basically same flow as today minus the engineers. Most of this is even possible today. The only thing saving engineering necks is the context window size which prevents fitting the whole repo in memory. Hopefully we (the programmers) will build our savings to a sustainable level in the next 5 years before signing off on manual coding or finding another thing to do than typing on keyboards to make computers dance.

My guess is it's sooner than later. First to go would be UI programmers and automation testers. Last would probably be the hardware interfacing engineers like embedded etc. May be writing code manually would be equivalent of using punch cards or artisan bread :)

Frankly I feel like we are looking at this the wrong way. In the future we might not even have a way to program some things manually. There might be a llm for each device that generates necessary hardware instructions on the fly like today's jit based on natural language or environment. May be there would be a inter llm spec/language that would felicitate cross llm functionality. All short circuiting out the programmers between the user and the utility.

Well the research is on rats. not to mention that the glycine specific one is funded by a glycine selling company. But despite all that, glycine has strong research backing it especially for reducing inflammation and allergies.

Probably a form of proof of work which is costly for the bots but fair on normal users (combined with normal fingerprinting and IP check which determines how hard the challenge should be for a request)

Occam's razor tells us that if it's a great architecture/technical breakthrough, it would have taken the world by storm by now. Similar to the original transformer paper and model. Since 2017, the only successful models are variations of transformers. RNNs are no where in the picture.

Simply believing a architecture is superior doesn't make it so. Nothing converges and performs as good as a model with attention in both training and inference. The difference is night and day.

What if they only accepts payments to their out of Norway bank accounts

Don't read them for the sake of reading them. Read them to solve your current problem or trying to keep up with advancements in a narrow field you love. Most papers (especially the ones in deep learning) seem to also have a mathematical fetish (to put it mildly) where needless representations are used where none are required and are self evident (for example inputs belong to Real number set). It ends up making the paper pseudo complex and unapproachable. Most papers are doing average/summation/series operations but instead of just saying so, use the symbols all over the place. So even if a few papers appear tough, keep reading them and digest your first paper thoroughly. You will find subsequent papers mostly are a rehash of existing work with similar fetish to make trial and error appear like mathematically sound research. Once in a while, you would find some paper which is fully theoretical and try to prove that either the inputs/outputs/components of models have certain well known mathematical properties and hence can be reasoned similarly. These are rare and would be difficult to parse through.

PS: Best papers I have seen are from deepmind where the approaches usually described are novel, varied and path breaking. Worst ones are - well no names but those that just use training and eval sets generated by GPT4 and try to prove things empirically

What part of attestation don't you understand? If linked with a OS level signing with keys stored on TPM, it's game over for private browsing. The only thing worse than companies proposing such measures are the useful idiots downplaying the impact. If someone disagrees, pray tell us muddle brains how to bypass this on a proprietary OS with locked boot and tpm stored keys.

All are priced $39.95 per book. One book would get 2 months of gpt4 access. I don't see many technical books taking off anymore except for may be as reference books. It's much easier to learn any language with a LLM than with books (obviously anecdotal).

Thanks for making this. Was searching for a pure rust GPT implementation just the other day!

Yes. Seems to have definitely gone down. Not sure what they have done but even with things it used have no trouble with, it struggles now. Most likely they are experimenting on reducing the compute per request.

One good thing about these pointless forks is, they help reduce the number of people who are in it for the drama and get emotionally turbulent for every disagreement. Eventually people who actually care for the language and invested in its long term success remain. I wish the crab people well and hope they never decide to come back to Rust.

PS: Can't help but chuckle reading people's comments on wanting to either abandon Rust or not try it. Used to be that languages were picked based on use case/fit. Then it turned to hype cycle. And now it's going to be based on people drama ?

Thank you for the pointer. Very interesting approach. If you don't mind could you suggest some resources where I could learn more about your approach.

Thanks for suggesting tree of thought. Will try the approach they mentioned in the paper.

Kind of I guess. If it is a single step: That is modify or generate text (could be code or anything) in a specific way, it works great even on obscure things.

However if the problem is stated in a way that it has to think through derivative of it's solution: that is generate some code that generates some other code which behaves in a certain way, it fails miserably. I'm not sure why. The problem I stated in current thread which it failed on I have tried multiple prompts to make it understand the problem but unfortunately nothing worked. It's as if it can do first level but but not second level abstraction.

Aah, in case it wasn't clear the use case I'm trying to solve is exactly that: piping shell commands to and fro so that LLM has a bit of autonomy. I know that things like LangChain, AutoGPT exist but frankly they are really poorly thought out and seem to have become kitchen sinks too fast without solving anything properly.

I have cleared my chat history recently so don't have all the prompts but here is a recent use case I used it for: Prompt: "Generate a react mui component that fetches a Seller's shipping credits and shows his current credit balance in the top portion. There should be a recharge button next to the credit balance. The bottom portion should show recent transactions. Use below api for fetching credit balance: <api req/resp>. Use below api for fetching the transactions: <api req/resp> Recharge should be done with the below api: <api req/resp>

Make the component beautiful with good spacing, elevation etc. Use Grid/Card components."

Final result: https://res.cloudinary.com/dksmi6x98/image/upload/v168527409...

Most code files are usually too large to 'cat' because of the context size limitations. Even if they fit within the context window, it's waste of API credits to provide it the information that it doesn't need.

Anyways posting this here isn't to get this particular problem solved. It is to see if there is a prompt that can solve it. And this is the only problem I found it not able to solve. It's not like it doesn't know about sed/awk/grep or other Linux tools, it is an expert on most of the common options involving them. My guess is there is something going on with this prompt that just breaks it's 'though patterns' for the lack of a better word :)

That would mean nothing because GPT4 isn't most people. I had it solve more complex problems than this particular one and using the same tools :)

I was able to get gpt4 to do a lot of useful work. But for some reason it completely falls apart for this scenario. May be because it has to think in second order to achieve the task. Perhaps you could take a crack at this:

Prerequisite (for you the human)> You have a file at src/SampleReactComponent.jsx that has below simple react component: const SampleReactComponent = (props) => {

    const [var1, setVar1] = React.useState(false);
    const [var2, setVar2] = React.useState(false);
    const [var3, setVar3] = React.useState(false);

return (<></>); };

export default SampleReactComponent;

********** Prompt for GPT4: I'm at my project root working on a reactjs project. Update the component in src/SampleReactComponent.jsx file by adding a new const variable after the existing variables. You cannot use cat command as the file is too big. You can use grep with necessary flags and sed to achieve the task. I'll provide you the output of each command that you generate. *************

That's it. It would do any complex modification on fully provided data (included in the prompt) but something like above where it has to build a model from secondary prompts will totally fall apart.

My experience has been polar opposite with GPT4. As long as I structure my thoughts and present it with what needs to be done - not like a product manager but like a development lead, it spits out stuff that works on first try. It also writes code with a lot of best practices baked in (like better error handling, comments, descriptive names, variable initialization).

Some times this presenting of problem to it means I spend anywhere from 5-10 mins actually writing the points down that describes the requirement - which would result in a working component/module (UI/backend).

We have been trialing GPT4 in my company and unfortunately almost everyone's experience is more on the lines of yours than mine. I know it shouldn't, but honestly it frustrates me a lot when I see people complain that it doesn't work :). It definitely works but it depends on the problem domain and inputs. Often people forget that it has no other context about the problem than just the input you are providing. It pays to be descriptive.

Looks great. Is it possible to use css frameworks with it (let's say bootstrap etc). I'm trying to understand where this fits in the overall stack. Is it possible to use react libraries with it.

Well, if we are not interacting with them, will they be alive ? It's not like they are thinking without prompts. Once they start a continuously running inner monologue with themselves and modifying their weights on the fly, we can probably classify them as beginnings of AGI. We do more brutal things to other beings that think and feel pain on a daily basis.

It's even worse. Most lab grown stuff has to use this : https://en.wikipedia.org/wiki/Fetal_bovine_serum

As a vegetarian, I would say - continue to eat the animals than putting the animals through the dystopian hell that produces animal based nutrient solutions. I would also bet that most of the people looking forward for lab grown meat would be repulsed by what exactly they are eating if they understand the production process

Aah yes. Dairy consumption is at same humane level as procuring fetal bovine serum: https://en.wikipedia.org/wiki/Fetal_bovine_serum

Because kids (and in general humans) are not robots and need love of their parents ? Instead of exploiting immigrants for their wombs, let them in like any other non robotic thinking society does.

Hope it will slowly percolate down to other companies which copied this shitty work culture while not providing any other benefits that the FAANG provided.