StackOverlord

Then let's make some industrial grade apophenia machine.

https://www.youtube.com/watch?v=0xOGeZt71sg

https://youtu.be/0Y8v3X6Oft4

I'd be really interested in generating on the fly numerical apophenia like those. In fact I dabbled into doing exactly that using GPT to code a python script. I ran L-BFGS-B on a unit pyramid to optimize its basic dimensions (height, base-length, set to 1 initially) so that it matches the pyramid equations [1]. As a result I get the pyramid's actual dimensions. My synthetic pyramid is slightly better than the actual pyramid when it comes to matching the "pyramid equations". I know this is tautological, yet when I observe the actual pyramid dimensions and where it fits on the gradient magnitude graph my script[2] provides, it falls right when the gradient becomes almost flat. That made me want to explore further, and I attempted to come up with my own crackpot equations using symbolic regression/genetic programming[3]. The ultimate goal: a VR app, let's call it the "conspiracy lens".

[1]https://tobeornottobe.org/the-great-pyramid-intro/math-const...

[2]https://pastebin.com/TsUtcWAa

[3]https://pastebin.com/9CEU76K6

There's a field studying this kind of stuff: https://en.wikipedia.org/wiki/Relevance_theory

And look what I found: https://journals.openedition.org/tipa/3068 – Louis de Saussure & Tim Wharton, 2019

Seems like the de Saussure family still has a very robust scientific tradition. The most famous of the de Saussure, Ferdinand, founder of synchronic linguistics, got trapped into an apophenia trap with his theory of "hypograms" underlying saturnian verses. More at https://www.degruyter.com/document/doi/10.1515/sem-2016-0158...

This is basically the middleware pattern except that each function is responsible for calling the next function in the chain. As a consequence, and contrary to the classic middleware pattern, the chain goes both ways, up to thhe api call, and down returning the result. The first expr is indeed special. It is in this context a level 0 function: it takes a context, does stuff, and returns the context. The other functions in the threading/-> expression are level 1 function: they return a level-0 function, in short they act like a factory. That returned function will be then threaded into the following level 1 function and so on. In the end the defined 'chatgpt' element is the whole chain. Call order is to be read from bottom to top.

Here's how level-1 functions are defined. 'ctx-fn' is just an indirection macro for 'fn' I haven't really used yet.

    (defn preserve-ctx [f & [at]]
      (let [mem (or at (atom {:ctx true}))]
        (ctx-fn
         :preserve-ctx [ctx]
         (if (->> ctx :it (cmd? :preserve-ctx))
           (do (case (:it ctx)
                 :preserve-ctx/get   @mem
                 :preserve-ctx/reset (doto {:ctx true}
                                       (->> (reset! mem))))
               (println (-> ctx :it) "done."))
           (-> ctx
               (when-not-> (-> :states :preserved)
                           (as-> $ (ctx-it (merge @mem $) (-> $ :it))))
               f
               (assoc-in [:states :preserved] true)
               (doto (->> (reset! mem))))))))

Edit: reading what I wrote, 'endpoint' is in fact a function returning function, except that since it's the "end" of the chain, it doesn't take a function to call next as argument.

I use lambda over let over lambda (lolol)[1] like this (Clojure):

    (def chatgpt
      (-> (endpoint :chat "gpt-4" auth)
          (chat/set-opts [:endpoint] {:stream true})
          chat/retry
          chat/catch-unkown-commands
          ;; chat/history
          chat/string-input
          (chat/file-io "file.txt" :stream true)
          #_(chat/preserve-ctx chatgpt-ctx)))

These higher-level functions take as input the next function in the chain, and return a function that is responsible for calling it and takes a context hashmap as argument. Additionally, you can pass messages to these functions like :history/reset, impacting the atom defined in the let part of lolol. I use the same pattern for higher level constructs:

[1]https://letoverlambda.com/index.cl/guest/chap2.html#sec_6

Evidence for a Large Anomalous Nuclear Explosions in Mars Past J.E. Brandenburg

https://www.hou.usra.edu/meetings/lpsc2015/eposter/2660.pdf

Compiling source code doesn't cost million of dollars though

You can introduce indirection layers without OOP since a function's signature is its interface. I do it all the time.

Inform7 Actions and Rules system made me reconsider the centrality of the notion of Object when it comes to dispatching (note: Inform7 reads like english). Inform7 takes a verb-centric stance, then consider the subject (i.e. "this", in OOP), then the object (i.e. the arguments to a method). You can inject more specific behaviors in an action (i.e. something akin to a multimethod in CLOS), by adding an adjective to a verb/method complement/arguments. You can even use adjectives on the verb/sentence. All of this is gathered within a rulebook associated with the verb that exists aside of the actual source code: you can write code linearly, following the natural order of a given user story from the domain you model, using multiple verbs in succession, but can still display all a verb's rule, encompassing many user stories. Most importantly, it is truely extensible because you can't add code to an action's rulebook without doing so through a rule, which has the same role as a junction-point in aspect oriented programming or even subject-oriented-programming.

https://en.wikipedia.org/wiki/Subject-oriented_programming

https://en.wikipedia.org/wiki/Aspect-oriented_programming

https://ganelson.github.io/inform-website/book/WI_12_1.html

https://ganelson.github.io/inform-website/book/WI_19_1.html

Related: https://longnow.org/essays/richard-feynman-connection-machin...

I favor ChatGPT over Google Translate now. ChatGPT has the added benefit it is focused on providing helpful answers, so if it comes across something almost untranslatable, it will be able to address that and provide an explanation in the style of a footpage note.

I've experienced a different situation where I was one of two pros – pillar may be more appropriate – in a team of around 15 devs – and wasn't recognized as such. I was working 70h/week on average (I never was paid for those overtime hours and my actual hourly wage was under the minimal wage), taking in charge every and any issue that may pop up, I was a reference when it came to knowing how our system worked and people would come ask me questions about the inner working of some part even when they had designed it ! I left disgruntled, and the other piller followed course because I wasn't here anymore to buffer the conflict he had with the CTO. In spite of the new hire and organizational restructuration to fill the gap, what should have taken 2 weeks to implement (a few hours to a few day in the redesign I had reimplemented at home in the weekend following my departure), took them 6 months. They had to distribute overtime hours to every dev, and in the end I received a call from the guy in charge of HR who told me the company was considering rehiring me at the condition I should behave ! Dude was fired eventually and replaced by a manager from the holding company.

As for pros needing training by other pros, I think it's more a question of culture. Once I was tasked with adapting a microservice to also run as a library, the challenge being we used JSON fields and now also had to store them in a mysql database that did not support them natively. I wrote an adapter that could have been released as a separate library because it was that generic, it took me 1 day of work, a 15 files long PR. But because it used a postwalk traversal on tiny json data triggered lazily upon accessing the specific field, cached in the ORM object for repeated access, it smelt funny to the CTO who proceeded to ditch my work away, spend the 3 following days adapting 350 files to try to get a highly specific solution then gave up, and decided in the end we'll have two separate versions of that system, in concurrent use, one as a lib and one as a microservice, hence multiplying by two the time it took to do changes to that highly repetitive codebase because "it was simpler that way".

You don't need to train pros, they have been training on their own since they are twelve.

Same problem with the comment box in Reddit.

Related C2 wik page:

https://wiki.c2.com/?SufficientlySmartCompiler

Get the best of both world by mocking the database API itself. Use the mocks to memoize the db output. Disable the mocks if you need long thorough tests. Determine if the mocks need to be disabled by comparing the date of the last thorough check with the date of the last db schema change. Instead of something global like this, one could come up with something local to the test file, using a system of cassettes. Doing something like this would require to make the database a value and memoize according to its current state, but I think it's doable.

95% of unit tests will bring 5% of value and 5% of unit tests will bring 95% of value.

Most unit tests should be handled at the integration level.

Been there, except I was the pizza being eaten by 5 microservices.

It can come up with its own concepts too. Or at least fresh, smart names for these concepts.

User: I've invented, with my friend, a new concept that is symmetrical to that of "universal": we've called it the "adverse." We're now exploring adjacent notions such as universe, universal, universial, and god. ...

Assistant: ...

4. God is often conceptualized as the ultimate universal, the unity that transcends and governs all realities. In this view, God would be the final organizing principle of the universe, the principle that gives meaning to everything. Conversely, in the adverse, there might be a concept like the Adieu (a pun on "adieu" and "God"), which would be the ultimate possibility, the principle that gives birth to an infinity of distinct and unique realities. The Adieu would not be an organizer, but a facilitator, allowing each reality to follow its own unique laws and to realize its own unique possibilities.

The FBI plants group leaders. It's always the same pattern. The Proud Boys leader also was a FBI informant.

https://www.reuters.com/article/us-usa-proudboys-leader-excl...

I use GPT to write code sometimes instead of importing a library. For instance a function to breadth first traverse a directed acyclic graph and slice it into levels. Another one to find a node in a nested graph using partial paths. I could have written those functions, but GPT4 does it correctly and faster.

In dwarf fortress: https://dwarffortresswiki.org/index.php/DF2014:Computing#Min...

> the macro can implement a whole new syntax and semantic -> then to say the enclosed items are 'args' is misleading: it's source code in a new sublanguage with a different syntax/semantics.

Not exactly. It still needs to conform to something the Lisp Reader can absorb, i.e. something that looks like lisp. Then there are reader macros. That's where the true extensibility resides (and in addition to the new syntax elements, you'll need to reserve boundary keywords for that syntax).

I have a question: how do these systems handle webhooks ? Do they generate event handlers too ? I'm asking this because notions like "quality of service" are essential when you're dealing with the semantically asynchronous parts of an API. With MQTT you can chose between QOS 0 (at most one, this is fire and forget HTTP events, very bad), QOS1 (at least once) and QOS2 (exactly once). This imply coding some kind of broker that will track the state of the communication and carry it to its completion.

This problem can be addressed with chat history summarizaton. Langchain has some tools to do that

Can confirm both point 1 and 2. I sometimes burn my quota limit multiple times a day. I have API access to GPT-4 too, and question+answer in my case amounts to $0.3. Aligning the price of GPT-4 in the API with the monthly fees of ChatGPTPlus, that means 66 requests per month. I can burn that in day.

> Yes, one of the board members of OpenAI, Will Hurd, is a former government agent. He worked for the Central Intelligence Agency (CIA) for nine years, from 2000 to 2009. His tour of duty included being an operations officer in Afghanistan, Pakistan, and India. After his service with the CIA, he served as the U.S. representative for Texas's 23rd congressional district from 2015 to 2021. Following his political career, he joined the board of OpenAI 1 【15

> network error

https://openai.com/blog/will-hurd-joins