faizshah

The argument has never changed the argument has always been the same.

LLMs do not think, they do not perform logic they are approximating thought. The reason why CoT works is because of the main feature of LLMs, they are extremely good at picking reasonable next tokens based on the context.

LLM are good and always have been good at three types of tasks:

- Closed form problems where the answer is in the prompt (CoT, Prompt Engineering, RAG)

- Recall from the training set as the Parameter space increases (15B -> 70B -> almost 1T now)

- Generalization and Zero shot tasks as a result of the first two (this is also what causes hallucinations which is a feature not a bug, we want the LLM to imitate thought not be a Q&A expert system from 1990)

If you keep being fooled by LLM thinking they are AGI after every impressive benchmark and everyone keeps telling you that in practice LLM are not good at tasks that are poorly defined, require niche knowledge, or require a special mental model that is on you.

I use LLM every day I speed up many tasks that would take 5-15 mins down to 10-120 seconds (worst case for re-prompts). Many times my tasks take longer than if I had done it myself because it’s not my work im just copying it. But overall I am more productive because of LLM.

Does LLM speeding up your work mean that LLM can replace Humans?

Personally I still don’t think LLM can replace Humans at the same level of quality because they are imitating thought not actually thinking. Now the question among the corporate overlords is will you reduce operating costs by XX% per year (wages) but reducing the quality of service for customers. The last 50 years have shown us the answer…

It was surreal seeing Fox News have polymarket bets being taken on what Trump would say side by side with him speaking.

And I don’t even know what to say about the president and First Lady releasing official meme coins…

I love this, the biggest problem I have right now with python scripts is distributing my single file utility scripts (random ops scripts).

I wish there was a way to either shebang something like this or build a wheel that has the full venv inside.

It’s not even good at writing unit tests. It’s good at writing bad unit tests but that’s not the same thing.

This might be more useful than the OP. This thing lets you translate HAR to Swagger…

My usual process is Dev tools -> Copy as CURL -> delete unnecessary headers -> translates to requests in python (these days I just use ChatGPT) -> wrap in python sdk for managing auth etc.

The OP’s correlation features are really nice though.

I believe this is just a wrapper around pygwalker, which is a nice project: https://github.com/Kanaries/pygwalker

I really like the typescript graphic walker: https://github.com/Kanaries/graphic-walker

Did I miss it or did they say whether o3 is going to be available under ChatGPT Plus or Pro?

It’s a monkey’s paw solution, now you have 15 kinda slow pipelines instead of 3 slow deployment pipelines. And you get to have the fun new problem of deployment planning and synchronizing feature deployments.

It seems to be that it is faster and cheaper with slightly lower than SOTA quality. There’s an emerging subset of AI companies building features on “good enough” lightweight models: https://www.wired.com/story/how-do-you-get-to-artificial-gen...

So I guess that’s who it’s for.

I’ve only spent an hour with it though obviously.

I love this, I first learned Java and “Kids Programming Language” (a strange action script-y flash inspired thing) in elementary school and the lessons I learned there stuck with me until today.

I would highly recommend parents consider teaching their kids using processing (p5.js), it’s super visual but still “real” code so you still build that muscle memory of thinking in loops and typing out real code: https://p5js.org/tutorials/

There’s lots of art and games to be inspired by: https://openprocessing.org/browse?time=anytime&type=tags&q=g...

And there’s some great books from dan shiffman on it that are super visual but still teach programming concepts: http://learningprocessing.com/ https://natureofcode.com/

When you start out programming that young it is hard to go from idea to thing on the screen doing what you want. So the advantage of using processing is it keeps kids engaged and removes the frustration of not making progress since everything is visual you’re always moving around stuff on the screen every frame so it’s quick and easy feedback.

This is really impressive, I would suggest benchmarking it against Vespa as well I have gotten better perf results from Vespa than Lucerne/Solr/ES.

I’ll take a try this weekend as well.

Thanks for the link I think this is a really interesting example:

> In qSQL this is: aj[`sym`time; t; q], which means perform an asof-join on t, looking up the nearest match from table q based on the sym and time column.

> In standard SQL, again you’ll have difficulty: sql nearest date, sql closest date even just the closest lesser date isn’t elegant. One solution would be:

> WITH cte AS (SELECT t.sym, t.time, q.bid, ROW_NUMBER() OVER (PARTITION BY t.ID, t.time ORDER BY ABS(DATEDIFF(dd, t.time, p.time))) AS rowNum FROM t LEFT JOIN q ON t.sym = q.sym) SELECT sym,time,bid FROM cte WHERE rowNum = 1

> It’s worth pointing out this is one of the queries that is typically extremely slow (minutes) on row-oriented databases compared to column-oriented databases (at most a few seconds).

This is a really nice example but I think it’s more about this as of join being a really useful operation, it appears both pandas https://pandas.pydata.org/docs/reference/api/pandas.merge_as... And duckdb https://duckdb.org/docs/guides/sql_features/asof_join.html

Pandas:

> pd.merge_asof(t, q, on='time', by='sym', direction='backward')

Duckdb:

> SELECT t.sym, t.time, q.value FROM t ASOF JOIN q ON t.sym = q.sym AND t.time >= q.time;

So it seems more like this is benefitting from a useful feature of time series databases rather than the features of an APL-family language.

Personally I find the pandas syntax to be the most straightforward here.

I 100% agree, I think the functional features that have been added across all the popular languages (map, reduce, fold etc.) has been a positive. Nothing demonstrates it better (imo) than purrr in R: https://github.com/rstudio/cheatsheets/blob/main/purrr.pdf

I also think there is some merit to “high syntactical density” clearly if you can see the entire code in one place instead of having to navigate through many files or sections that’s beneficial. (Heavily discussed in the last big HN thread: https://news.ycombinator.com/item?id=38981639)

I also think JQ has proven the merit of tacit functional languages in that you can concisely write arbitrary transforms/queries on json that can be more expressive than SQL (many SQL engines have added JSONPath anyway). And I also think postfix is great for processing pipelines.

But I am not totally convinced in the approach of APL/J/Q/KDB for the combination of terse style + prefix + tacit because it makes the code so difficult to read. I think if you took an approach similar to JQ where instead of relying on symbols operators were just human readable words it would be easier to get us half way there to trying out the verb, adverbs etc. approach of the APL family. The problem with making it human readable text is that you lose the conciseness which is part of the draw of the APL family as they want to have a high syntax density and analogous code to mathematical expressions.

I’ve tried several times to give J/k/Q/kdb a chance but I haven’t really found a convincing example why this approach is better than say SQL or say numpy/jax etc.

The syntax has the same problem as perl in that you have to learn too many symbols that are hard to look up. And this combined with the tacit style makes it difficult to parse what the code is doing.

I think ruby went in the radically opposite direction in that it provides a similar feature set to perl with similar functional features but everything is human readable text. I feel like there’s room for a human readable version of J that relies less on syntactical sugar.

I do think the direction Klong has gone with the syntax is an improvement: https://t3x.org/klong/ambiguity.html

I’m curious if anyone has a go-to article/example of why an array language would be a good choice for a particular problem over other languages?

I know the second chapter of J for C programmers is kinda like that but I didn’t really find it convincing: https://www.jsoftware.com/help/jforc/culture_shock.htm#_Toc1...

> sum::{+/x}

> count::{#x}

These two expressions are not valid in R or Python. They are implicitly declaring a function without declaring the arguments, it is implicitly iterating over the array and returning the result (all features of array languages to make it more concise).

Python’s + and / are a function of two objects (dyadic) and are syntactic sugar (they can’t be treated as function values, thats what the operator module is for): https://docs.python.org/3/reference/datamodel.html#object.__...

The array languages optimize for concise code so a lot of things are done implicitly that are done explicitly in Python.

The python equivalent:

> _sum = lambda x : functools.reduce(operator.add, x)

> _count = lambda x: functools.reduce(lambda acc, _: acc + 1, x, 0)

Of course in python and R there are built ins for these already (sum(x) and len(x)) but this is just to show what array languages are doing for you.

So it’s basically a standardized plugin format for LLM apps and thats why it doesn’t support auth.

It’s basically a standardized way to wrap you Openapi client with a standard tool format then plug it in to your locally running AI tool of choice.

Capistrano, Ansible et al. have existed this whole time if you want to do that.

The real difference in approaches is between short lived environments that you redeploy from scratch all the time and long lived environments we nurse back to health with runbooks.

You can use lambda, kube, etc. or chef, puppet etc. but you end up at this same crossroad.

Just starting a process and keeping it alive for a long time is easy to get started with but eventually you have to pay the runbook tax. Instead you could pay the kubernetes tax or the nomad tax at the start instead of the 12am ansible tax later.

On the flip side there are many engineers who are so afraid to build anything that seems even a little bit difficult you end up with a million dependencies for things that could have been 100 lines of code.

A common thing to hear in frontend these days is “you’re just rebuilding X” “you mean you want to rebuild X” where X is some trivial flavor of the month library.

All of the famous tools, databases and frameworks you see today was built by someone who said they can do it better and then they built a community around it.

I’m asking more about what techniques did they use to get the performance improvements in the slides.

They are showing a 20-30% improvement over Polars, Clickhouse and Duckdb. But those 3 tools are SOTA in this area and generally rank near eachother in every benchmark.

So 20-30% improvement over that cluster makes me interested to know what techniques they are using to achieve that over their peers.

It’s not clear to me why this would be faster than polars, duckdb, vaex or clickhouse. They seem to be taking the same approach of multithreading, optimizing the plan, using arrow, optimizing the core functions like group by.

Pandas is a commonly known DSL at this point so lots of data scientists know pandas like the back of their hand and thats why a lot of pandas but for X libraries have become popular.

I agree that pandas does not have the best designed api in comparison to say dplyr but it also has a lot of functionality like pivot, melt, unstack that are often not implemented by other libraries. It’s also existed for more than a decade at this point so there’s a plethora of resources and stackoverflow questions.

On top of that, these days I just use ChatGPT to generate some of my pandas tasks. ChatGPT and other coding assistants know pandas really well so it’s super easy.

But I think if you get to know Pandas after a while you just learn all the weird quirks but gain huge benefits from all the things it can do and all the other libraries you can use with it.

How do you crawl or backfill the existing data?

Like if you wanted to implement a search engine or recommendation system it’s not clear to me how you retrieve a training set.

In general, you can save your team a lot of ops trouble just by periodically restarting your long running services from scratch instead of trying to keep alive a process or container for a long time.

I’m still new to the erlang/elixir community and I haven’t run it in prod yet but this is my experience coming from Java, Node, and Python.

PyApp is really good for this: https://github.com/ofek/pyapp

It is just a way to wrap your python code into a self bootstrapping executable: https://ofek.dev/pyapp/latest/runtime/

You can get it setup pretty easily with hatch: https://hatch.pypa.io/1.9/plugins/builder/app/

But yea I agree the problem with python is there isn’t a tool like deno that just does everything that has to do with packaging, locking, venvs, and building a cross platform binary.

I have seen the opposite happen a lot though, even if a project is successful you will get numerous people coming to you asking “who approved this? Why was I not involved in the decision?” And the ballooning aftereffects are why it takes months to push a simple button.

Big companies are like government bureaucracies now.

Anyone come up with good techniques for reverse engineering websockets?

Its especially annoying since many use binary message formats and there isnt a great way to document an arbitrary binary message protocol.

A couple techniques im trying out:

- websocat and wsrepl for reverse engineering interactively: https://github.com/doyensec/wsrepl

- kaitai struct for documenting the binary message formats: https://kaitai.io/

You just described the value proposition of RAG.

Anecdotally but I still get significantly better results from ChatGPT than claude for coding.

Claude is way less controllable it is difficult to get it to do exactly what I want. ChatGPT is way easier to control in terms of asking for specific changes.

Not sure why that is maybe the chain of thought and instruction tuning dataset has made theirs a lot better for interactive use.

I think bad OOP is still better than bad functional code. Having seen what happens when a React codebase reaches >100k LOC are we really any better off than a class hierarchy?

The OOP model fits nicely into most people’s heads because of the analogy to the real world and OOP implementations generally seem to give better signals when you are doing something wrong. Rather than functional implementations which mainly rely on human expert code reviewers and linters to give negative signals instead of say exception hierarchies.

A lot of the time you don’t realize your codebase is bad until “it’s just a button how hard can it be” somehow takes 3 months and 4 rollbacks.

At least this is what I have observed working on large codebases.

Amazon has one of the lowest average tenures in the industry. The number of engineers and teams that existed pre-2020 under those working conditions is tiny (except maybe the leadership teams).

Once you have worked a remote/hybrid software job with a remote team you can’t put that genie back in the bottle (or something like that, that DHH said).