xtreak29

Bun is moving towards rust but does this also help bun's compilation times?

https://ziggit.dev/t/bun-s-zig-fork-got-4x-faster-compilatio...

Reviewing code was also a big bottleneck. With lot more untested code where authors don't care about reviewing their own code it will take even more toll on open source maintainers. Code quality between side projects and open source projects are different. Ensuring good code quality enables long term maintenance for open source projects that have to support the feature through the years as a compatibility promise.

https://stackoverflow.com/q/3177338

There seems to be an issue open for this https://github.com/simsong/tcpflow/issues/58

Does aioboto3 help here?

https://aioboto3.readthedocs.io/en/latest/usage.html#upload

Some breakdown and comparison over the years https://meta.m.wikimedia.org/wiki/Wikimedia_Foundation_salar...

https://streamlit.io/ is good for quick interfaces with components.

You can get top PyPI package source using https://github.com/hugovk/pypi-tools/blob/main/repo_checker....

https://github.com/hugovk/pypi-tools

https://github.com/hugovk/pypistats

Probably a reference to https://news.ycombinator.com/item?id=32531141

Some discussion on this in PostgREST repo

https://github.com/PostgREST/postgrest/issues/1214

I used rewriting as a learning experience. I found flutter to be simpler with respect to UI and state management compared to using XML by default for UI. Since mine was a crud app flutter was okay. I later found jetpack compose which has flutter like UI composition and I liked it better since I can access the existing Android library ecosystem too.

I too wrote a similar app for my personal problem and also served to be a good way to learn about kotlin and Android ecosystem. I also tried a rewrite in flutter and compose. The idea was to use select the word and then click meaning from context menu so that meaning occurs as notification and disappears in 15 seconds. I used Wiktionary as dataset source and app works offline.

https://play.google.com/store/apps/details?id=com.xtreak.not...

https://github.com/tirkarthi/NotificationDictionary

GitHub repo : https://github.com/readysettech/readyset

There was a similar PEP https://peps.python.org/pep-0505/

If you have the openapi spec then tools like below might help

https://dev.to/danielgtaylor/a-cli-for-rest-apis-part-1-104b https://github.com/danielgtaylor/restish https://github.com/danielgtaylor/openapi-cli-generator https://github.com/OpenAPITools/openapi-generator

Thanks, your sqlite-utils and other libraries have been very helpful.

Discussion: https://sqlite.org/forum/forumpost/d61880668db1a8f4

Thanks

In case of PostgreSQL there is json and jsonb. For SQLite, hexdump of the database shows text representation and seems to be stored like json than jsonb. I am not aware of the full design and source code but it seems some functions parse and cache the JSON representation.

https://github.com/sqlite/sqlite/blob/a0318fd7b4fbedbce74f13...

https://www.postgresql.org/docs/current/datatype-json.html

The json and jsonb data types accept almost identical sets of values as input. The major practical difference is one of efficiency. The json data type stores an exact copy of the input text, which processing functions must reparse on each execution; while jsonb data is stored in a decomposed binary format that makes it slightly slower to input due to added conversion overhead, but significantly faster to process, since no reparsing is needed. jsonb also supports indexing, which can be a significant advantage.

It seems readfile is from an extension but present in cli. json_each is present in standard sqlite core from 3.38.0 as json1 extension is also now part of core.

json_each : https://www.sqlite.org/json1.html#jeach

readfile : https://sqlite.org/cli.html#file_i_o_functions

Note that the readfile(X) and writefile(X,Y) functions are extension functions and are not built into the core SQLite library. These routines are available as a loadable extension in the ext/misc/fileio.c source file in the SQLite source code repositories.

There are couple of threads related to json import but a default mode will be helpful as there is already .mode json for output and import support will be great.

https://sqlite.org/forum/forumpost/567caa57234b98e46b885bcf8...

https://sqlite.org/forum/forumpost/f4b44e09cea20851014420a8b...

sqlite-utils is also a helpful project for various utilities : https://sqlite.org/forum/forumpost/ff5b6198eb6e794d2f774ce06...

I guess you are trying to do below from your comment.

  $ echo '["Kate", "John", "Jim"]' > names.json
  $ ./sqlite3
  SQLite version 3.38.0 2022-02-22 18:58:40
  Enter ".help" for usage hints.
  Connected to a transient in-memory database.
  Use ".open FILENAME" to reopen on a persistent database.
  sqlite> create table users(id integer primary key, name text);
  sqlite> insert into users(name) select value from json_each(readfile('names.json'));
  sqlite> select * from users;
  1|Kate
  2|John
  3|Jim

Thanks, opened an issue for discussion : https://github.com/ipython/ipython/issues/13445

Thanks for the release. I just upgraded and error messages are really nice. One bit I might be missing is that Python 3.10 added suggestions for AttributeError and NameError. It seems the suggestions are not stored in the exception object but calculated when Error is displayed. There is a note that that this won't work with IPython but it will be good to check if it's feasible.

https://bugs.python.org/issue38530 https://docs.python.org/3/whatsnew/3.10.html#attributeerrors

Larry Wall is at Craigslist

Thread with Mozilla's post :https://news.ycombinator.com/item?id=24120336

There were some optimisations done in https://bugs.python.org/issue26219

From Python 3.8 there is AsyncMock : https://docs.python.org/3/library/unittest.mock.html#unittes... . It's also available on mock backport from pypi for other versions. It's based on asynctest module. https://pypi.org/project/asynctest/

This might help : https://automatetheboringstuff.com/2e/chapter18/

At pypistats.org download numbers of the last half year can be found. * python3-dateutil has 271 downloads from non-mirrors in last month[1]

* jeilifish has only 106 downloads from non-mirrors in last month[2]

[1] https://pypistats.org/packages/python3-dateutil

[2] https://pypistats.org/packages/jeilyfish

https://news.ycombinator.com/item?id=21702973

And infrastructure cost is 2-3 million dollars per year to have PyPI running. https://twitter.com/dstufft/status/1127320131359653890