codewithcheese

You have merged the 2 things the post keeps apart - capacity and attention over it.

Maybe you just write like an LLM.

So in this scenario you could input something like: { NodeType: Person, EdgeTypes: [IS_PARENT_OF, IS_CHILD_OF] }

RDF, OWL are existing formats for defining a schema

Domain driven design is well aware that is not feasible to have a single schema for everything, they use bounded contexts. Is there something similar for the semantic web?

Yes, looks like they could be adapted to create Story Maps

Looking forward to their durable execution Workflows. Writing Temporal workflows has great DX but their pricing and hosting requirements put it out of reach for many projects.

That's openrouter, they are listed

Think chromium compile is widely used

- Monorepo with FE, BE and shared types - React + Next.js (frontend) - pnpm - Nest.js (server) - Tailwind - Material UI - Apollo (GraphQL) - Jest (Testing) - Typescript + ESLint + Prettier + Husky - Turbo - TypeORM - Segment - Database migrations - Docker - Logging (Pino.js)

How will non-tech founders develop their product on this stack? That's a stack for developers to build the product.

This is a very hard problem, when you see a fragmented ecosystem its because players in the ecosystem have wide ranging and demanding requirements.

You will have to acquire your target customer when they are ready to setup this stack but before they have done so themselves. This would require very high brand awareness. Like "Oh I was going to setup on AWS but XYZ makes it so easy". Only a few companies have achieved this type of awareness in the devops space. Heroku comes to mind. None of them are indie-hacker projects.

How are you using Generative UI?

It can be faster and more effective to fallback to a smaller model (gpt3.5 or haiku), the weakness of the prompt will be more obvious on a smaller model and your iteration time will be faster

Yeah also prompts should not be developed in abstract. Goal of a prompt is to activate the models internal respentations for it to best achieve the task. Without automated methods, this requires iteratively testing the models reaction to different input and trying to understand how it's interpreting the request and where it's falling down and then patching up those holes.

Need to verify if it even knows what you mean by nothing.

Leetcode correlating with IQ tests makes sense they are very similar. Correlating either with general intelligence is less obvious.

Vervel charges $400/TB for excess bandwidth, it's not even DDoS you should worry about, just moderate success.

Strange loop, one of the few conferences where videos from 10 years ago are still relevant today, will be missed.

Retrospective https://www.youtube.com/watch?v=suv76aL0NrA

Pasted your comment in ChatGPT Plus, it did a search and found the link

https://www.remote.org/frederik/projects/railserver/history....

I think it got relatively lucky with the query, since tried a few variations, you.com and Perplexity and they all failed to find it.

Hi, nice idea. I recently learnt about framer, haven't tried it yet. They have a publishing features. Have you used framer? How would you compare your work with theirs?

https://www.framer.com/

As a non academic this is an example in how to express a simple opinion with structure and references. My first reaction was to think this is much ado about nothing, but then I saw it provides a small map one can use to start to navigate this topic.

Cool, sent you an email to the address on your profile

Yes within a timezone is a good idea. I am based in Australia, teaching myself deep learning, and happy to connect with anyone in Asia. Of course happy to connect with anyone globally, but being in a similar timezone can lead to more serendipity

If the context size is unbounded, how does the time complexity scale with the size of the context, and what are the limiting factors that affect performance as the context size grows larger?

What makes it "clean" vs animal grown meat?

Interested to see a GPT version of this and compare.

How about a browser extension that scrapss Google results and asks GPT to summarise?

There are many prompts beyond summarisation that would be interesting, for example ask GPT to present conflicting point of views in the results.

"why is the state of education so abstract and uninspiring?" witch have a simple answer

They are answering why education is "so abstract and uninspiring", talking about the educational system specifically. Not peoples abilities. They are actually implying that people could understand if given the chance.

Hi, last time I checked out dagger, plans were built using CUE, has CUE been dropped? Dont see any mention of CUE anywhere. If so, is there a write up about the change of plan? Thanks

Cool, I wasn't aware, thanks. https://nim-lang.org/blog/2020/10/15/introduction-to-arc-orc...

The main difference between ARC and Nim GCs is that ARC is fully deterministic - the compiler automatically injects destructors when it deems that some variable (a string, sequence, reference, or something else) is no longer needed. In this sense, it’s similar to C++ with its destructors (RAII). To illustrate, we can use Nim’s expandArc introspection (will be available in Nim 1.4).

This shows one of the main ARC features: scope-based memory management. A scope is a separate region of code in the program. Scope-based MM means that the compiler will automatically insert destructor calls for any variables which need a destructor after the scope ends. Many Nim constructs introduce new scopes: procs, funcs, converters, methods, block statements and expressions, for and while loops, etc.

ARC also has so-called hooks - special procedures that can be defined for types to override the default compiler behaviour when destroying/moving/copying the variable. These are particularly useful when you want to make custom semantics for your types, deal with low-level operations involving pointers, or do FFI.

No, Nim doesn't have stronger or weaker safety guarantees than Rust [1]. Rust's memory safety is nothing new, either. It is mostly that some older languages like C/C++ are the exceptions in not being memory-safe. There is nothing new or magical about memory safety. LISP was already memory-safe when it was invented in 1958. The only question is how much performance you need to trade away for it (the value is never zero for non-trivial programs, but can vary greatly, depending on whether the language was designed with it in mind or not).

The main difference between Rust and other languages is that it does some more (but not all [2]) safety checks at compile time rather than at runtime. It also allows you to avoid GC, but does not provide you any memory safety over GC. Rust's borrow checker allows you to statically prove that references are live [3]; a GC simply avoids deallocating any memory that has a live reference to it (on the other hand, a GC can ensure that references remain live even where this is hard or impossible to prove statically). The end result is the same with respect to memory safety (the reason some people want to avoid GC is for performance reasons, not memory safety).

https://forum.nim-lang.org/t/1961

Thanks, didnt know that. What was his stated motivation?

Thanks for sharing, this is great. Firefox on Android has some support for bookmarklets, you can search for them in the address bar. This is more convenient. Why didn't this get more appreciation?

What does "Spike rough prototypes" mean?

I presume this is an Americanism.

Google offers this download link for the PDF, works for me: https://canvas.harvard.edu/files/1871005/download?download_f...