☆ Yσɠƚԋσʂ ☆

  • 18 Posts
  • 101 Comments
Joined 5 years ago
cake
Cake day: January 18th, 2020

help-circle




  • The big difference with R1 at least is that it is trained using reinforcement learning, and it gives you an explanation of how it arrived at a solution. I find the thinking bit is really fascinating cause it really reads like a train of thought. Here’s an example of what it outputs when I ask it to write a react component with a text input and a button:

    <think> Alright, the user asked for a React component that includes a text input and a button. I need to write this in a way that’s clear and functional.

    First, I’ll start by setting up the basic structure of a React component. I’ll import React and useState since we’ll need state management for the input value.

    Next, I’ll create a functional component called TextInputButton. Inside this component, I’ll use the useState hook to manage the text input’s value. The initial state can be an empty string.

    Then, I’ll define a handler function, handleChange, that updates the state whenever the user types into the input. This function will take the event object and set the new value using setTextInputValue.

    I also need a function to handle the button click. For now, I’ll use handleClick with an alert message as a placeholder. The actual functionality can be added later based on requirements.

    In the return statement, I’ll structure the JSX. I’ll include an input element of type text, binding its value to the state variable and attaching the handleChange function to the onChange event. This ensures that the state always reflects the current input value.

    Below the input, I’ll add a button element. On clicking this button, it will trigger handleClick. I’ll also give it a class for styling purposes, like ‘button’ which can be styled with CSS if needed.

    Finally, I’ll export the component so it can be used elsewhere in the application. I’ll make sure to include comments explaining each part for clarity. </think>

    Here’s a simple React component with a text input and a button:

    import React from 'react';
    import { useState } from 'react';
    
    function TextInputButton() {
      const [text, setText] = useState('');
    
      const handleChange = (event) => {
        setText(event.target.value);
      };
    
      const handleClick = () => {
        // Add your click handler logic here
        alert('Button clicked!');
      };
    
      return (
        <div>
          <input
            type="text"
            value={text}
            onChange={handleChange}
            placeholder="Enter text..."
          />
          <button onClick={handleClick}>Submit</button>
        </div>
      );
    }
    
    export default TextInputButton;
    

    This component:

    1. Uses useState to manage the input value
    2. Has a handleChange function that updates the state when the user types
    3. Has a handleClick function that currently just shows an alert (you can add your own logic here)
    4. Renders an input field and a submit button

    You can use this component in your application like:

    <TextInputButton />
    

    The input value is controlled through the text state variable, and you can access it using text. When the button is clicked, the handleClick function will execute whatever logic you need.















  • So, what you’re actually saying you’d rather live under capitalism because it’s not impacting your freedom, and you don’t care about others. Meanwhile, claiming that western Germany was economically stronger than the USSR is another example of you being divorced from reality. It’s the same sort of logic people applied to modern Russia comparing its GDP to Italy. Now, it turns out Russian industrial production is higher than all of the west combined. This is how capitalism rots people brains, they start thinking imaginary numbers are more important than material reality.


  • It’s a tool with some interesting capabilities. It’s very much in a hype phase right now, but legitimate uses are also emerging. Automatically generating subtitles is one good example of that. We also don’t know what the plateau for this tech will be. Right now there are a lot of advancements happening at rapid pace, and it’s hard to say how far people can push this tech before we start hitting diminishing returns.

    For non generative uses, using neural networks to look for cancer tumors is a great use case https://pmc.ncbi.nlm.nih.gov/articles/PMC9904903/

    Another use case is using neural nets to monitor infrastructure the way China is doing with their high speed rail network https://interestingengineering.com/transportation/china-now-using-ai-to-manage-worlds-largest-high-speed-railway-system

    DeepSeek R1 appears to be good at analyzing code and suggesting potential optimizations, so it’s possible that these tools could work as profilers https://simonwillison.net/2025/Jan/27/llamacpp-pr/

    I do think it’s likely that LLMs will become a part of more complex systems using different techniques in complimentary ways. For example, neurosymbolics seems like a very promising approach. It uses deep neural nets to parse and classify noisy input data, and then uses a symbolic logic engine to operate on the classified data internally. This addresses a key limitation of LLMs which is the ability to do reasoning in a reliable way and to explain how it arrives at a solution.

    Personally, I generally feel positively about this tech and I think it will have a lot of interesting uses down the road.