urschrei

Oh and I forgot to add that Vladimir Agafonkin and Morgan Herlocker’s JS libraries (earcut, rbush, delaunator, turf, polylabel) have dragged state of the art spatial analysis into the browser to an extent that won’t be equalled again in the foreseeable future. Just a ridiculously deep bench.

I can’t speak to the organizational problems you saw, but when you consider the quality of software that Mapbox was producing before the failed union drive – Mapbox GL JS, Rasterio, Shapely – what you’re saying is nonsensical. The latter two libraries have of course left Mapbox, along with their creator, and continue to see high-quality new features, but Mapbox GL JS is still so much better than anything else that I continue to use and pay for it, even though my friends and acquaintances were the people who quit after Mapbox management torpedoed the union drive (note: I’m relying on the current NLRB complaint against Mapbox here: https://www.nlrb.gov/case/20-CA-283393) and I hope that one day I’ll have an alternative.

With the greatest respect, nothing about his comment is inflammatory in the least, and I say this as someone who is avowedly skeptical about the ability of the Julia creators to accept criticism.

Is it too late to rename the language to Ostrich?

I can imagine many reasons why attempting to create 17k items via the web API without some kind of batch processing and/or rate limiting may not have been a successful endeavour.

I’ve been using Zotero since it was in beta in 2007, and have a library with tens of thousands of items. As dstillman says that’s hardly unusual. It works perfectly (it’s just a SQLite db with a mature, well-designed schema after all), and syncs perfectly across five devices.

Nonsense. Landsat 8 bands 5, 6, and 7 are infrared bands (5 is NIR, and 6 & 7 are shortwave or SWIR), and bands 10 and 11 are lower-resolution thermal infrared (TIRS).

Source: http://www.usgs.gov/faqs/what-are-band-designations-landsat-...

OK, I'll say it because nobody else seems to want to: the sensible approach would be to ask for some help on one of the several official avenues that are open to you: users.rust-lang.org to begin with, and then the Discord (if you're comfortable with Discord). Aside from the high quality of help available to anyone, of any proficiency level, there's a pretty good chance you can describe your problem to someone who worked on Rust in Firefox.

But why bother with that when you can write passive-aggressive blog posts that are devoid of useful information about the errors that were encountered instead.

The deal explicitly states that the company doesn’t have to engage in collective bargaining about wages, so this seems like little more than PR at this stage, unless there’s a broader strategy.

Thanks – this is the more informed version of what I wrote.

> There is no problem at all interfacing Julia's C API to Rust

Nobody claimed there was a problem?

> As for the FUD about interfacing JIT code to C/C++

I don't know what you're talking about. Sorry!

Rust doesn’t need to copy the data. It’s trivial to pass e.g. Numpy arrays to Rust as slices via Cython (let alone originating in Cython!), modify them, and return them, or use them as input for a new returned struct.

https://github.com/urschrei/simplification

https://github.com/urschrei/lonlat_bng

https://github.com/urschrei/pypolyline

Each of those repos has links to the corresponding Rust “shim” libraries that provide FFIs for dealing with the incoming data, constructing Rust data structures from it, and then transforming it back on the way out.

As a more general comment, using a GC language as the FFI target from a GC language is begging for difficult-if-not-impossible-to-debug crashes down the line.

An entire industry – geospatial – and a variety of related industries depend on high-performance CH, Voronoi, and line simplification algorithms, among others. Not to mention their importance in medical imaging applications, tomography (so, in a sense, they directly contribute to healthcare improvements). This should be self-evident, but I can provide further direct evidence if need be; I’ve implemented QuickHull, Visvalingam-Whyatt etc from the papers, and the resulting libraries see enthusiastic use in a variety of sometimes surprising fields. They get lots of attention because the problem domain is well-understood and often resistant to low-hanging optimisation efforts (computational geometry algorithms tend to be difficult to optimise)

Here's the "report card" (PDF) on the app's data-gathering and privacy features, prepared by the Irish Council for Civil Liberties: https://www.iccl.ie/wp-content/uploads/2020/07/ICCL-DRI-HSE-...

The report is thorough, informative, and technically competent, IMO.

It's absolutely not an alternative to RustEnhanced. Sublime-LSP + Rust-Analyzer complement RustEnhanced, adding Language Server functionality. They don't conflict in any way.

Source: me, a contributor to both RustEnhanced and Sublime-LSP

Are you sure? Wes McKinney rewrote the Pandas CSV parser way back in late 2012 because the batteries-included version was slow and memory-hungry. Did Python upstream his version later on, or replace it with something faster (I'd be surprised if they did either, but I'd be curious to know)

Jaguar's I-PACE has OTA updates.

Matplotlib is verbose, and has had an inconsistent API in the past (v3 has improved this a lot), but if you need to produce publication-quality figures using Python, taking the time to get comfortable with it pays off. I've been using it to produce maps and data visualisations for years – when I finally figure out how to make something look good, I put the notebook on Github, both for my own reference, and for others: https://github.com/urschrei/Geopython

Particularly now that it's relatively straightforward to bake and serve your own MVT tiles, so you're not tied into the Mapbox service ecosystem if you don't need any of its other features (and you're happy with the scale / performance of your own tile server(s))

I'm by no means an expert, but yes, if you can use a modern realisation (e.g. ITRF2014) and have access to VLBI / DORIS / GNSS then sub-centimetre accuracy is possible, though not in real time.

Survey-grade GPS (using CORS and WAAS correction) using RTK will give you accuracy to ~10 cm within a few seconds. You can get that down to several millimetres if you can tolerate post-processing several hours worth of static data.

basemap (like matplotlib) has the contourf method. You can calculate your x, y, and z values using matplotlib.mlab.griddata (altho scipy's are faster), and pass the results to it:

https://stackoverflow.com/a/26885815/416626

TfL is not fully self-funded, or even close to it. It derived 47% of its funding from fares in 2017/2018. https://tfl.gov.uk/corporate/about-tfl/how-we-work/how-we-ar.... In fact, it's facing a large (close to £1 bn) deficit this year due to falling passenger numbers.

Resistance from a community is not a "restriction", and characterising this as NIMBYism would be intellectually dishonest if it weren't so ridiculous. Google is not a group, it's a vastly wealthy and powerful corporate entity, and objecting to its presence in a community is not a slippery slope or precedent-setting in the sense which you (again, preposterously) imply.

Turf development is funded by Mapbox. If you need more Geo functionality than that provided by https://github.com/georust/rust-geo (I'm one of the developers), contributions are actively encouraged, and we're happy to mentor people. Alternatively, feel free to pay for some dev time if you need something specific (e.g. OpenCage paid to have their geocoder included in https://github.com/georust/rust-geocoding, dual-licensed as Apache / MIT).

Who, ever, anywhere, has claimed that "Rust fixes all possible problems"? This is a straw man. As for bad code leading to overflows and crashes: yes, bad code causes overflows and crashes, definitionally. Rust does not, and has never claimed to protect against logic errors in this way. How could it?

I don't think you can make SSL work on AWS without Route53, though. Which is (for better or worse) about to become a big problem when Google starts penalising non-SSL sites. You also can't make a AAAA record, so no IPv6.

You'll have to have a first in order to be able to skip the masters, and since entry to funded programs is competitive, you have to be an exceptional candidate for this to actually happen – it's quite rare.

Then there's the program itself. DTCs (doctoral training centres) now mostly run 3 + 1 programmes, where your first year is a master's, involving taught classes and a research project. This is to get everyone up to speed on how to actually do independent research, and to build core skills. While it's true that teaching doesn't always form a mandatory part of a doctoral degree, working as a teaching assistant for at least one semester is often mandatory.

In short, you've mischaracterised doctoral education in England and Wales (Scotland may be different) to quite an extraordinary degree. I see no reason to comment upon the "more than our top share" claim, for reasons which are, I hope, obvious.

The difficulty of writing self-referential data structures in Rust arises on HN often. Every time, the answer is, broadly, the same:

- It is certainly difficult

- Strategies and approaches from low-level languages which are at least cosmetically similar will probably be unavailing

- In some (many?) cases, crates (Rental, Petgraph, Spade) exist that already implement them. Their design can be studied

- There's an entire book (http://cglab.ca/~abeinges/blah/too-many-lists/book/) devoted to writing linked lists in Rust. It's highly informative

Without wishing to explicitly criticise your approach to learning Rust, I'll note that for the vast majority of programmers, it's likely to be frustrating for quite a while.

It's really shocking to me that years later, nobody has addressed the most serious issue (community interaction) Dan brought up. Just reading the archived mailing list thread I could not believe the suspicion, and later outright hostility towards Dan's comments. It obviously dawned on a couple of core contributors, as can be seen by the sheepish attempts to walk things back, but this sort of interaction _with the project leadership_ is a giant red flag about how they view their community and users. If someone like Dan can be treated in that way publicly (and far worse privately, according to his own account), things are going to be so much worse for other people.