I thought I'd reply as I like reading in-depth discussions online, so I don't want to see a future where everyone assumes long comment = AI. :)

(I know this is an 8-day old thread, but accusing a long comment of being AI-generated is a bad trend.)

As a developer, "infinite scroll to get more digits" sounds really cool. It sounds conceptually similar to lazily-evaluated sequences in languages like Clojure and Haskell (where you can have a 'virtually-infinite' list or array -- basically a function -- and can access arbitrarily large indices).

As a user, it sounds like an annoying interface. On the rare case I want to compute e^(-10000), I do not want to scroll for 3 minutes through screens filled with 0s to find the significant digits.

Furthermore, it's not very usable. A key question in this scenario would be: how many zeroes were there?

It's basically impossible to tell with this UI. A better approach is simply to switch to scientific notation for very large or very small numbers, and leave decimal expansion as an extra option for users who need it. (Roughly similar to what Wolfram Alpha gives you for certain expressions.)

Performing arithmetic on arbitrarily complex mathematical functions is an interesting area of research but not useful to 99% of calculator users. People who want that functionality with use Wolfram Alpha/Mathematica, Matlab, some software library, or similar.

Most people using calculators are probably using them for budgeting, tax returns, DIY projects ("how much paint do I need?", etc), homework, calorie tracking, etc.

If I was building a calculator app -- especially if I had the resources of Google -- I would start with trying to get inside the mind of the average calculator user and figuring out their actual problems. E.g., perhaps most people just use standard 'napkin math', but struggle a bit with multi-step calculations.

> But for some reason the authors of calculator apps never optimize them for the number of keypresses, unlike Casio/TI/HP. It's a lost art. Even a simple operator repetition is a completely alien concept for new apps.

Yes, there's probably a lot of low-hanging fruit here.

The Android calculator story sounded like many products that came out of Google -- brilliant technical work, but some sort of weird disconnect with the needs of actual users.

(It's not like the researchers ignored users -- they did discuss UI needs in the paper. But everything was distant and theoretical -- at no point did I see any mention of the actual workflow of calculator users, the problems they solve, or the particular UI snags they struggle with.)

https://cdn.britannica.com/43/70143-004-CCB17706/theorem-dem...

It is not immediately obvious why the area of the hypotenuse square should be equal to the sum of the areas of squares drawn on the other two sides of the triangle.

It is clear that the lengths of a, b and c are connected -- if we are given the length of any two of (a, b, c), and one angle, then the remaining side can only have one possible length.

So far, so simple; what is less clear is why the exact relationship for right triangles is c^2 = a^2 + b^2.

The other proofs demonstrate that the relationship holds, but give little insight.

The geometric proof linked above makes the relationship crystal-clear.

For any right triangle we can define a 'big square' with sides (a + b). The hypotenuse square is simply the area of the 'big square' with 4 copies of the original triangle removed.

Simple algebra then gives us the formula for the hypotenuse square:

The big square has area: (a+b)^2 = a^2 + 2ab + b^2

The original triangle has area: ab/2

1 big square minus four original triangles has area: (a+b)^2 - 4ab/2 = a^2 + b^2

Similarly, if you take the hypotenuse square, and subtract 4 copies of the original triangle, you get a square with sides (b - a). This is trivial to prove with algebra but the geometric visualisation is quite neat, and makes clear why the hypotenuse square must always equal the sum of the other two squares.

However, Patrick Mackenzie is a person of the highest calibre (see, e.g., this: https://worksinprogress.co/issue/the-story-of-vaccinateca/).

There is a need for laws, and there is a need for laws that respect freedom. As of 2023, the details of how a freedom-respecting social system would work have only been scantily developed.

If men like patio11 aren't convinced by the pro-freedom case, why would anyone else be?

The libertarian movement has supported many bad actors. Cryptography has supported many evil acts. Libertarianism is not bad and cryptography is not evil; but no-one serious will follow us until we clean up our act.

(It's not enough to say that the current system is bad or worse. The current system is terrible. But we should be aiming to set things right, not simply tweak things on the margin.)

These are the best approaches:

1. "Please take out the trash."

2. "The trash needs to be taken out. Can you do it?"

3. (If there are several people around). "The trash needs to be taken out. Who can do it?"

Extra consideration:

I'm assuming this refers to a context where there's a prior agreement in place that A can tell B what to do (e.g. a business, where B signs a contract stating that he has sold X hours/day to the organisation). It usually should be unnecessary to bark out orders or to beat around the bush -- both are insulting: if B is a functioning adult they accept that they work for an organisation and so need to complete certain tasks.

However, direct instructions are rarely necessary for knowledge workers or highly-skilled professionals. Unless things have broken down horribly, they're aware that the success of the business they work for will contribute to their own career success.

E.g., instead of "you will write unit tests today" or "would you mind terribly writing unit tests today?", A would do best saying something like "we're introducing too many regressions when we change things, we need a better testing strategy -- let's discuss our approach to unit testing" and then let the team weigh in with their own ideas so they have ownership over whatever is decided.

"We will distribute tools to leverage the power of these white box models, and create a developer community around our trademark. This approach is an ideological differentiator from OpenAI; it is a very strong point argument for hiring highly coveted top researchers, and a strong accelerator for development, as it will open the doors for many downstream applications from motivated hackers."

So they're trying to build a community of inventive 3rd party developers, however:

"Business development will start in parallel to the first model family development, using the following strategy

- Focus on exploring needs with a large industrial actors, accompanied by third-party integrators that will be given full access to our best (non-open source) model"

Suggests they be will sucked into the enterprise market as I said above. Still, the last line:

"Co-design of products with a few small emerging partners that focuses on generative-AI products."

Suggests a wildcard: one of these "small emerging partners" might come up with the $trillion black-swan application of AI.

[I'm going to bookmark this comment and reread it 2 years from now to see how wrong I was]

(Even if they don't get government funding, it looks like they've already positioned themselves to get a ton of support from the EU and from European national governments, who want local champions to compete with the American capitalists.)

My thoughts:

- it's a fairly well-written memo: clear, concise, and relatively well-structured. It's a refreshing alternative to the endless series of pitch decks which mainly induce groupthink.

- the insights aren't that original. I would guess that they are strongest on the technical level. Their product and industry insights are less original or penetrating (pushing open-source and the European angle may give them some advantages -- it almost certainly will not give them an edge over OpenAI, who seem to have a relentless focus on iterating their product, a "live player" CEO in sama, and a strong dose of healthy scrappiness and creativity.)

- my prediction: they will stick around for a time, build something impressive with their technical team, raise more funding, hire a large and strong technical team (with their enormous warchest, status as the European champion, and appeal to the open-source community), and basically become a solid "fast follower". However, I think it's less certain whether they'll be able to do anything really creative or innovative.

Their overwhelmingly strongest market is going to be large European enterprises (or maybe governments), who will have lots of specific niche problems. The downside of that is their org then moulds itself to fit the needs of enterprise customers.

More speculative: the only way they can really become dangerous will be by attracting a bunch of young top-notch 18-25-year-old devs, ML people, or other builders (basically, people with creative energy and without commitment to the "established ways of doing things"), throwing them in a room together, and giving them a remit to come up with the most crazy, ambitious, unexpected applications of AI that they can. A universal translation app customised for the needs of ERASMUS students. Some weird generative music app for Berlin nightclubs. The actual ideas don't matter, what matters is having 50-100 hyperactive GenZ builders energetically exploring the space of combinations of technology, product and market to identify the genuinely novel applications of AI.

But I predict that they will not do that. You cannot cultivate that kind of free-spirited entrepreneurial DNA while simultaneously seeking deep connections with the European political establishment.

So, my overall prediction: they will focus on the underlying technology and on connections with governments/large enterprises, and deemphasise product innovation. Basically, building an AI-powered French IBM, rather than Google+++++. (Google+++++ will be built by one or two lone young researchers following their noses and working on weird esoteric ideas.) If I am right, and product innovation is the key to harnessing the power of generative models, then these guys in Paris will be formidable but not dangerous.

Should be interesting to watch it play out!

I have no doubt that hundreds of millions of BS jobs exist, but isn't that what management consultants are supposed to fix?

Whether or not management consultants actually do fix wasteful jobs is another issue. But my understanding of the sector was that it was aimed to fix these issues. Organisational refactoring, if you will.

Likewise, everyone complains about bad management, but good management is supposed to be able to fix the kind of issues Graeber describes. Steve Jobs' return to Apple in the late 90s is a famous example.

Years ago on this site someone who worked in senior management in a tech company told a story. It went something like this: there were two teams in the company, who were always complaining, not very productive, and seemed to waste enormous amounts of time and energy on pointless busywork or trying to coordinate tasks. Everyone on team A blamed team B, everyone on team B blamed team A, etc, etc. The manager realised this needed to be fixed, talked to the relevant people on both teams, figured out what the problem was, and ... fixed it. (I have no recollection of what the actual problem was -- let's suppose it was some kind of communication or process issue.) After that, things ran smoothly.

Is this story realistic? No doubt -- after all anyone who has worked in engineering is familiar with chronic technical problems that can be fixed with very small amounts of work -- if one has the requisite knowledge. And no doubt there are chronic human problems that are similarly solvable.

Anyway - after many rounds of such management fixes you would have an organisation that ran like a swiss watch. In such places, good managers, like good sysadmins, fade into the background and become invisible. Google in the 2000s may have been a good example. But eventually either the organisation grows, or the good managers leave, or -- most likely -- people decide they no longer need to worry about good management, the organisation begins to rot, and eventually they're forced to bring in bad management. Corporate entropy proceeds in the usual way, and you end up with waste, bad practices, poor communication, doomed projects, crappy output, politics, and -- BS jobs.

This is why I'm skeptical of political intellectuals like Graeber who note a problem but misidentify the solution. Some of the things he categorises as "BS jobs" are themselves intended to fix BS jobs.

But I do not have much experience working in large organisations, so perhaps someone else can chime in.

  Where did Person get the spoon from?

I apologize for the oversight. Here is the corrected version, including the step to get the spoon:

Person: {The tea is ready. I need a spoon to stir it.} Get a spoon from the kitchen drawer. Computer: You have taken a spoon from the kitchen drawer.

Person: {Now I can stir my tea.} Stir the tea with the spoon. Computer: You have stirred the tea with the spoon.

Person: {Time to enjoy my tea!}

I have to snip some prompts for brevity, but here's the gist. I first asked it to list the rooms in a typical apartment and how they are connected. Then I gave it the following prompt:

  Write a table that lists the furniture and other large items that appear in each room. The table should list the name of the item, the room it appears in, its approximate size, and its other attributes.

  Then, create another table that lists the small items that appear in each room. [snipped the rest of the prompt for brevity]

  Item Room Size (LxWxH, cm) Attributes

  Sofa Living room 200x90x85 3-seater, upholstered, with cushions

  Coffee table Living room 100x60x45 Wooden, rectangular

  TV Living room 120x6x70 Wall-mounted, flat-screen, 55 inches

  Refrigerator Kitchen 70x70x170 Stainless steel, 300L capacity

  Cushions Living room Sofa 45x45x15 Soft, decorative

  Remote control Living room Coffee table 15x5x2 For TV

  Vase Living room Coffee table 15x15x30 Glass, decorative

  Flowers Living room Vase Varies Fresh or artificial

I then gave it the following prompt [I included an example of the original SHRDLU in the prompt, which I've cut here]:

  I want you to simulate the classic program SHRDLU by Terry Winograd. SHRDLU functions like above. You will simulate both "Person" and "Computer". "Person" will move around the apartment, pick up a coaster, move to the kitchen, and put the coaster on the kitchen island. After each action of "Person", "Computer" will give one sentence describing the position of the most-recently changed objects.

Person: Move to the living room. Computer: You are now in the living room.

Person: Pick up a coaster. Computer: You have picked up a coaster from the coffee table.

Person: Move to the kitchen. Computer: You are now in the kitchen.

Person: Put the coaster on the kitchen island. Computer: You have placed the coaster on the kitchen island.

Next prompt:

  Continue to simulate SHRDLU. "Person" goes through the stages to make a cup of tea. There is a bottle of milk in the refrigerator. At each step of the simulation, include "Person"'s thoughts in curly brackets, { }. See the example below. [Example snipped]

Person: {I feel like having a cup of tea. I need to go to the kitchen, boil water, and gather the necessary supplies.} Move to the kitchen. Computer: You are now in the kitchen.

Person: {I need to boil some water.} Fill the kettle with water. Computer: You have filled the kettle with water.

Person: {Now, let's boil the water.} Turn on the kettle. Computer: The kettle is now on and heating the water.

Person: {While the water is boiling, I'll get a teabag.} Get a teabag from the box of teabags. Computer: You have taken a teabag from the box of teabags.

Person: {Now I need a cup.} Get a cup from the cabinet. Computer: You have taken a cup from the cabinet.

Person: {I'll put the teabag in the cup.} Place the teabag in the cup. Computer: You have placed the teabag in the cup.

Person: {The water should be ready by now.} Pour the boiling water into the cup. Computer: You have poured the boiling water into the cup.

Person: {I need some milk.} Get the bottle of milk from the refrigerator. Computer: You have taken the bottle of milk from the refrigerator.

Person: {I'll add some milk to the cup.} Pour a small amount of milk into the cup. Computer: You have poured a small amount of milk into the cup.

Person: {The tea is ready.} Stir the tea with a spoon. Computer: You have stirred the tea with a spoon.

Person: {Time to enjoy my tea!}

Does anyone with more knowledge of the relevant mathematics (group theory and so on) care to chime in?

For things like creative writing, programming, summaries of historical events, producing basic analyses of countries/businesses/etc, I've found the incremental, trial-and-error approach to be best. For these problems, you have to expect that GPT will not reliably give you a perfect answer, and you will need to check and possibly edit its output. It can do a very good job at quickly generating multiple revisions, though.

My favourite example was having GPT write some fictional stories from the point of view of different animals. The stories were very creative but sounded a bit repetitive. By giving it specific follow-up prompts ("revise the above to include a more diverse array of light and dark events; include concrete descriptions of sights, sounds, tastes, smells, textures and other tangible things" -- my actual prompts were a lot longer) the quality of the results went way up. This did not require a "scientific" approach but instead knowledge of what characterized good creative writing. Trying out variants of these prompts would not have been useful. Instead, it was clear that:

- asking an initial prompt for background knowledge to set context - writing quite long prompts (for creative writing I saw better results with 2-3 paragraph prompts) - revising intelligently

Consistently led to better results.

On that note, this was the best resource I found for more complex prompting -- it details several techniques that you can "overlap" within one prompt:

https://learnprompting.org/docs/intro

*(For example, the idea of a "hierarchy of feedback loops" from perceptual control theory would explain a lot of the interactions between agents in his theory.)

I also put the abstract of the paper into GPT-4, and gave it the following prompt:

> Simplify the above. Use paragraph headings and bold key words.

I quite liked its output, as it made it easier to see the core ideas in the paper:

ABSTRACT

Generative Agents: This paper introduces generative agents, computational software agents that simulate believable human behavior. They can be used in various interactive applications like immersive environments, communication rehearsal spaces, and prototyping tools.

Architecture: The generative agent architecture extends a large language model to store a complete record of the agent's experiences in natural language. It enables the agents to synthesize memories, reflect on them, and retrieve them dynamically to plan behavior.

Interactive Sandbox Environment: The generative agents are instantiated in a sandbox environment inspired by The Sims, where users can interact with a small town of twenty-five agents using natural language.

Believable Behavior: The generative agents produce believable individual and emergent social behaviors, such as autonomously spreading party invitations and coordinating events.

Components: The agent architecture consists of three main components: observation, planning, and reflection. Each contributes critically to the believability of agent behavior.

KEYWORDS: Human-AI Interaction, agents, generative AI, large language models

I asked it to write a moderately complex algorithm, and it chose to write a function to compute the Pollard's Rho algorithm.

Then, with a few example comments to show what I meant, I asked it to annotate the code to show how the constraints on the variable changed as each line was executed.

This was its output:

  # n : an integer n > 3, no upper limit
  # seed : an optional integer parameter (default = 1) for the polynomial function
  # pollards_rho(n, seed) : an integer or nil, representing a non-trivial factor of n, or nil if the algorithm fails to find a factor

  def pollards_rho(n, seed = 1)
  return n if n <= 3

  x = 2
  # x : an integer, initially set to 2, will be updated using the polynomial function f
  # x will always be in the range [0, n)

  y = 2
  # y : an integer, initially set to 2, will be updated using the polynomial function f
  # y will always be in the range [0, n)

  d = 1
  # d : an integer, initially set to 1, will store the greatest common divisor of (x - y) and n
  # 1 <= d <= n

  while d == 1
    x = f(x, n, seed)
    # x : updated using the polynomial function f, x = (x * x + seed) % n
    # x will always be in the range [0, n)

    y = f(f(y, n, seed), n, seed)
    # y : updated using the polynomial function f twice, y = ((y * y + seed) * (y * y + seed) + seed) % n
    # y will always be in the range [0, n)

    d = gcd((x - y).abs, n)
    # d : the greatest common divisor of the absolute difference between x and y, and n
    # 1 <= d <= n, such that (x - y) % d == 0 and n % d == 0
  end

  d == n ? nil : d
  # Returns a non-trivial factor of n (1 < d < n) if one is found, or nil if the algorithm fails to find a factor

This is not actually the most impressive thing I've seen it do, but it illustrates that, even if GPT doesn't "really understand" code, it can emulate understanding to an impressive level. I'd go further and say that it opens up new questions as to what understanding actually means.

One personal "woah" moment was asking it to write some unit tests for a simple 2d game GPT and I wrote together. One function, "create_area" took a 2d array of characters (representing a map) and four integers representing coordinates, and a tile type. (The purpose being to create a rectangular area of the desired tile on the map according to the passed coordinates.)

GPT-4 successfully figured out how to write a unit test: it created a 5x5 array of ROCK tiles, passed it to create_area with the coordinates 1, 1 and 3, 3, and successfully figured out what the output should look like, even writing a fairly concise test to check the output (modified) 5x5 array. This was an eyebrow-raising moment for me: it made clear that GPT really does emulate some kind of "computation" internally, though quite possibly in some abstracted form. The geometric nature of this problem stuck out to me: a human can "see" a 2d array as a rectangular grid, and might realise the function carved out a smaller rectangle from that grid, but I never expected to see a computer (let alone a language model) figure it out. Interesting times, indeed.

https://www.youtube.com/watch?v=VznoKyh6AXs ["How to learn to code FAST using ChatGPT (it's a game changer seriously)"]

(Asking this makes GPT more effective when I ask it make further changes. One reason I do this is when I start a new session with ChatGPT discussing code it helped me write previously, especially if I've gone away and done a big refactoring myself.)

A very simple example is that I asked it to write some Ruby functions that would generate random creature descriptions (e.g., "a ferocious ice dragon", "a mysterious jungle griffin"). It did this by generating three arrays (adjectives, locations, creature types) and randomly selecting from them to build the output string. I then asked it to explain how many different descriptions it could generate, and it explained that multiplying the length of the three arrays would give the number of outputs. (125 for the first iteration, 5x5x5).

I then asked it how it would increase the number of possible outputs to 1000, and it did so by increasing each of the three arrays to length 10. I then asked it how it would generate millions of possible outputs, and it added extra arrays to make the creature descriptions more complicated, increasing the number of permutations of strings.

This is not the most sophisticated example, but it shows what GPT can do when it can combine "knowledge" of different areas.

If it's able to combine the solutions to known problems in a straightforward way, it can accomplish a lot. Beyond a certain point it needs guidance from the user, but if used as a tool to fill in the gaps in your own knowledge, its enormously powerful. I it more as an "intelligence-augmenter" than a "human-replacer".

See my comment here where I went into more detail on how I work with GPT: https://news.ycombinator.com/item?id=35197613

Yes, this is pretty much exactly the way I've been using GPT and it works tremendously well. (GPT4 works especially well for this style of programming.) My prompts include things like:

- "read the function below and explain in detail what each section does" -- this prompts GPT to explain the code in its own terms, which then fills in its context with relevant "understanding" of the problem. I then use the vocabulary GPT uses in its explanation when I ask it to make further changes. This makes it much more likely to give me what I want.

- "I see this error message, what is the cause? It appears to be caused by $cause" -- if I'm able to diagnose the problem myself, I often include this in my prompt, so that its diagnosis is guided in the right direction.

- "this function is too complex, break it up into smaller functions, each with a clear purpose", or "this function has too many arguments, can you suggest ways the code could be refactored to reduce the number of arguments?" -- if you go through several rounds of changes with GPT, you can get quite convoluted code, but it's able to do some refactoring if prompted. (It turned out to be easier to do large-scale refactoring myself.)

- "write unit tests for these functions" -- this worked phenomenally well, GPT4 was able to come up with some genuinely useful unit tests. It also helped walk me through setting up mocks and stubs in Ruby's minitest library, which I wasn't experienced with.

In brief, if you expect to just give GPT a prompt and have it build the whole app for you, you either get lame results or derivative results. If you're willing to put the effort in, really think about the code you're writing, really think about the code GPT writes, guide GPT in the right direction, make sure you stay on top of code quality, etc, etc, GPT really is an outstanding tool.

In certain areas it easily made me 2x, 10x, or even 100x more productive (the 100x is in areas where I'd spend hours struggling with Google or Stack Overflow to solve some obscure issue). It's hard to say how much it globally increases my productivity, since it depends entirely on what I'm working on, but applied skilfully to the right problems it's an incredible tool. Its like a flexible, adaptive, powered exoskeleton that lets me scramble up rocky slops, climb up walls, leap over chasms, and otherwise do things far more smoothly and effectively.

The key is you have to know what you're doing, you have to know how to prompt GPT intelligently, and you have to be willing to put in maximal effort to solve problems. If you do, GPT is an insane force multiplier. I sound like I work in OpenAI's marketing department, but I love this tool so much :)