otsaloma

IndexedDB is probably what's meant, Local Storage (if taken literally) is a simpler and perhaps too limited a solution. There are some options that make IndexedDB easier to use, I've been using PouchDB, which works well. If syncing to Dropbox, you'd then dump the database into a JSON string/file and use the Dropbox SDKs to sync that. If syncing to a database, you can do something more efficient.

Bort does just that, uses browser's IndexedDB and syncs via Dropbox. But note though, that it's not similar to Pinboard etc. in the sense that it's not designed for a huge archive of rarely accessed bookmarks. Works well for something smaller, like what people commonly have as browser bookmarks.

https://bort.io/

Some comparison on the about page against other services: https://bort.io/about.html

Looks really nice, I've looking to migrate away from Gitter, whose development stopped already long ago.

For open source project support channel use, I'd strongly recommend adding GitHub login. Most projects are hosted on GitHub anyway and users who have filed issues already have an account there. In my experience one of the most important features of an open source project support channel is as low of a barrier to entry as possible.

Agreed on the unsubscribe, I have two rules: (1) List-Unsubscribe header exists or (2) message body contains "unsubscribe".

I used to use a Nitter redirect extension, but whatever Nitter instance I was using was unbearably slow. I've now been using https://github.com/MaySoMusician/breakthrough-twitter-login-... . It seems to work fine (if login wall is your gripe with Twitter).

Not a big project, but just last week finished a visualization of electricity spot prices in Finland. Seems like a potentially difficult winter coming in Europe, using spot priced electricity and optimizing use would make sense. I didn't find a good visualization, so I made my own.

https://otsaloma.io/sahko/

Open source, GitHub link at the bottom of the page. The API used serves a large part of Europe, so you might be able to fork the code and adapt it to another country with fairly minimal work.

Really interesting. I too had a bicycle accident four years ago and have been really sensitive to bad ergonomics and spending too long in one position since. Just understanding what makes things worse and what better has been a big challenge. Coincidentally, just today I ordered a Håg Capisco chair, which serves the same purpose of allowing a variety of different positions with a standing desk and also makes it practically impossible to slouch. I'm hoping it'll help.

Debian unstable running here since about 7 years. I tend to reinstall when getting a new computer. Once I had X break and I had to set "GDK_BACKEND=x11" and "XDG_SESSION_TYPE=x11" to fix it. Something related to Wayland I guess. But I use startx directly, no login manager, so probably not a common issue.

Sometime more than five years ago, there was some trouble always when a new version of GNOME trickled to unstable one package at a time and having part of packages the old version and part new caused a lot of small issues, like thumbnails not working in Nautilus etc.

I don't remember any other relevant issues. apt-listbugs helps avoid a lot of issues. I use aptitude as package manager (commands, not the menu UI) and often use "aptitude forbid-version" to skip a bad version, not sure if apt-get or apt these days provide something similar. apt-listchanges is nice too, although I rarely see something relevant to me specifically there.

> I always found it odd that the rhetoric around transportation was that it should make money. We don't expect other parts of the government to turn a profit. Why transportation?

That sounds like a straw man. This probably varies, but where I'm from public transport is about half funded by ticket sales and half subsidized by tax payers (some of whom don't use public transport).

The reasons I'm aware of againt free public transport are (1) the economist view that a free service (that in reality costs money to operate) leads to inefficient and wasteful use and (2) the city-planner view that over long term free public transport leads to thinly spread out residential land use development which in turn leads to high infrastructure costs for roads, pipes, electricity, schools, etc. and also emissions as not everyone will use public transport for all their trips.

I think free public transport is an interesting thought especially give various modern challenges, but seems prone to shallow argumentation that doesn't quite match the complex dynamics of the matter itself.

By my experience engineers tend to way underestimate schedules and those are the two reasons. Best case scenario means no suprises come up during implementation, which is almost always false. Roughly double the best case estimate is usually about right. The second though can be a miscommunication, whether the estimate is an actual date when done or an estimate of the man-hours.

The author complains he couldn't add a Reddit RSS feed. I once looked into this. It was already a few years ago, but I guess it hasn't changed. The problem is that updating all Reddit feeds of all Feedly users goes way above Reddit's API call rate limits. So, it's probably simply not possible in a centralized free service. The problem isn't so much Feedly, but the various sites' (not only Reddit) ignorance or hostility towards RSS that results in these kinds of implementations.

Same as "explanatory variable" in the old (statistical) lingo.

Note that, unlike the title says, Albert is not open source. A while back the website claimed it was GPL, but there was no indication of that in the codebase. I filed an issue, which seems to now have been deleted, requesting to clarify the matter. Turns out the author has some reservations incompatible with any definition of open source and thus Albert is basically non-free source-available. This means that it's dead in terms of wider adoption – no distros will package it, that was directly reported by many package maintainers in the now gone issue.

> Finally: some portion of the hate it gets is probably from engineers without a statistics background who aren't familiar with the huge dictionary of jargon and abbreviations its APIs use.

Pandas' jargon isn't really even statistics jargon. For example data frames are tables, which are inherently rows and columns. Columns have names, rows can have names too (although that's not really needed). Pandas' documentation has very few mentions of rows and columns at all, instead they use "axes", "labels" and "index" and there's not even a proper explanation in documentation of what those mean. And that "index" is something that the user needs to manage, sometimes "drop", sometimes "reset" without really understanding why. It seems to me two things: (1) really bad choice of naming things and (2) exposing to users some performance-related details that should have been kept under the hood, if they are needed at all.

The examples presented are probably carefully selected, my experience is that if you actually use Pandas with method chaining, (1) you get ugly-looking code due to a mixture of method calls and various different kinds of bracket indexing and (2) you eventually run into things that just can't be (nicely) chained and then you need to break the chain – even new stuff, such as DataFrame.append being deprecated in favor of pd.concat.

Here's another alternative. I wrote Dataiter specifically as I too was frustrated with Pandas. In my experience if you design a new API from scratch (and don't try to reimplement the Pandas API as many projects have done!) and have some vision and consistent principles, it's well possible to get a good intuitive API as a result. Two relevant issues remain: You're limited by NumPy's datatypes and their problems, such as memory-hogging strings and a lack of a proper missing value (NA), and secondly, limited by the Python language, so compared to e.g. dplyr's non-standard evaluation, you'll need to use lambda functions, which are unfortunately clumsy and verbose.

https://github.com/otsaloma/dataiter

Here's a comparison of dplyr vs. Dataiter vs. Pandas, which should give quick overview of the similarieties and differences.

https://dataiter.readthedocs.io/en/latest/_static/comparison...

I think typically people don't start out thinking they'll use Numba, they start out using Python (for a multitude of valid reasons). Then eventually they want to optimize a single bottleneck at which point Numba makes a lot more sense than rewriting everything in Julia/Rust/whatever or calling some language from Python for which no convenient mechanism exists.

And when thinking about something more than optimizing a single function, but about a large codebase and the context in which you need it, Julia is rarely a compelling option.

How does JAX's JIT compare to Numba?

The range of longitude is longer (-180 to 180, total 360), latitude (-90 to 90, total 180).

I tried a couple of these command line tools recently, alass was the best of those. Really fast too. Still, it didn't work perfectly; I had subtitles for a different cut of a movie, it got two out of three segments right, but I had to manually fix the last segment. Either way, this is great development, I remember fully manual syncing being really troublesome.

If you use Pandas daily, maybe get used to it and can ignore the issues, but for anyone using Pandas occasionally, it's every time a huge pain trying to figure out how to use it. The API is not intuitive and the documentation is very verbose and unclear. And stackoverflow top answers are often the "old way" of doing something when yet another way of doing the same thing has been added to the API.

Agreed, dplyr is great.

I built my own data frame implementation on top of NumPy specifically trying to accomplish a better API, similar to dplyr. It's not exactly the same naming or operations, but should feel familiar and much simpler and consistent than Pandas. And no indexes or axes.

Having done this, a couple notes on what will unavoidably differ in Python

* It probably makes more sense in Python to use classes, so method chaining instead of function piping. I wish one could syntactically skip enclosing parantheses in Python though, method chains look a bit verbose.

* Python doesn't have R's "non-standard evaluation", so you end up needing lambda functions for arguments in method chains and group-wise aggregation etc. I'd be interested if someone has a better solution.

* NumPy (and Pandas) is still missing a proper missing value (NA). It's a big pain to try to work around that.

https://github.com/otsaloma/dataiter

Thanks for this. I've been using Beekeeper Studio (https://www.beekeeperstudio.io/) and I've been mostly happy with it, but glad to see alternatives. The only problem I have with Beekeeper is that scrolling the table view is really slow (laggy and jumpy), I assume it's because of Electron. Is DbGate any different there, you're using Electron too?

Because Pandas is built on top of NumPy and NumPy has never had a proper NA value. I would call that a serious design problem in NumPy, but it seems to be difficult to fix. There have been multiple NEPs (NumPy Enhancement Proposals) over the years, but they haven't gone anywhere. Probably since things are not moving along in NumPy, a lot of development that should logically happen at the NumPy level is now happening in Pandas. But, I agree, I find it baffling how Python has gotten so big in data science and been around so long without having proper NA support.

https://numpy.org/neps/#deferred-and-superseded-neps

hnrss is great. This is what most news sites get wrong, they might have RSS, but it gives you every new article and that can be over a hundred per day. And then they eventually conclude that no uses it and thus RSS is bad, when it's just their thresholdless implementation that's bad.

Great to see this! I've been looking at alternatives for experiment tracking, but most of what I've come across have looked way too heavy (and expensive) for a small team.

Is R support planned? Or might this just work already with reticulate?

Hi! Working in data science I spend most of my time downloading data, putting it together, cleaning or piping data somewhere. When working with R, I've learned to appreciate dplyr (and tidyverse) for their API consistency and the pipe operator, and I miss that when working with Python. Base Python and Pandas get the job done, but I find them often unpleasant to use.

So, I created a Python package with classes to handle different kinds of data, currently DataFrame for tabular data, ListOfDicts for possibly hierarchic data typically used with various JSON APIs, and the latest addition GeoJSON for spatial data. The classes provide various basic data manipulation methods.

My focus here has been on creating a nice API. I don't usually deal with huge datasets, so there's no performance innovation here. The DataFrame class in built on top of NumPy, so it does fast vectorized computation, but is likely to be a bit slower than Pandas.

Happy to hear any feedback and answer any questions!

I've been working on a data frame implementation for Python. I think API-wise we can do a lot better than Pandas. Especially after having seen and almost daily used dplyr with R, when having to use something else, I miss that convenience of a clear and consistent API and the chaining of operations. I don't know yet if this project makes sense in terms of speed and corner case handling. I haven't done any real-world work with it yet, but at least it's been a good learning project.

https://github.com/otsaloma/dataiter

https://github.com/otsaloma/dataiter/blob/master/dataiter/da...

PyOtherSide is a very nice option if you want to (or can get by with) using QML for the UI. Since it's a "bridge" instead of bindings, there's no inherent lag or instability ascpect to it.

https://thp.io/2011/pyotherside/

Even if you don't use multiple devices or browsers, browser databases are too mysterious for regular users -- too easy to accidentally delete along with history and too difficult maintain up-to-date backups of.