skysight-inc/HackerNews huggingface dataset:
> you don't need to contact S3 to get a presigned URL

Does this mean, in the example code on AWS where they import the AWS S3 library to create a presigned url, the library just generates it in situ instead of firing off a request to S3 asking for the URL?
America has a unique patriotic bias that keeps us from having nice things like health care and safe children.
Most of my serious work has been done with statically typed languages, though of course I have worked with dynamically typed ones as well. There are a few things about dynamically typed languages that seem to productivity-negative, but it may just be my lack of understanding of how people expert at a dynamic languages work with them.

1 - When working with a large enough code base that you don't remember exactly what every function you have written needs, or using third party libraries, function signatures lacking type specifications make it harder to know what is expected. if there is documentation that is good, you can of course load that up, but this slows you down. IDEs today can usually show you the function signature as you type it, but with dynamic types you get less information.

2 - When refactoring something in a statically typed language, changing a data structure or type name will cause the compiler to error every single place that you need to adjust for your change. With a dynamic language you need to rely on unit tests or you will be finding places you missed during runtime for a long time afterwards. If you do rely on unit tests for this kind of thing, then you have sort of built an effectively statically typed environment, at some large degree of effort, with worse runtime performance to show for it.

I understand some of the workarounds people use to deal with these problem but a lot of them seem to push you to the point that you might as well use static typing and get better runtime performance for it.
India’s ruling political party plagiarised a web template after getting hacked
Sure. There are additional tooling you can use in Rust and Go to catch a plethora of errors beyond what I described too. However if they require the user run them manually then they’re just as open to user error as the testing I also described. This is why having those checks in the compiler itself can be invaluable.
comparing apples and apples would be even less interesting.
You absolutely do though, that's the point.

You think that the e-waste you sent to recycling doesn't end up in trash, but you only have to look at places like Agbogbloshie, Accra, Ghana to see where some supposedly reputable recycling ends up.
How about proper widow/orphan control?
Strongly agree with author. I really like Python and at one point thought that it makes sense to write almost any project in it, since it's so versatile and I know it pretty well.

After working on a quite large application and having to use lots of assert(isinstance(arg, type) at the beginning of almost every function, I began to think that a strong type system is very much needed for large projects. I believe this was one of the reasons why Twitter moved from Ruby to Scala.

I still love to use Python for hacking something quick for myself. But I also look at some popular strongly-typed languages now and hope to get better at one of them soon.
>Having dynamic types can be awfully convenient at times and I completely relate to why some people like them but static types means your structures and classes effectively have written specifications defined in the code itself which the compiler verifies the rest of your program against. So if you’re accidentally trying to write text to a numeric type, your compiler will catch that.

In my experience, if I'm writing relatively decent tests and sprinkling of sanity checks these types of errors get caught quickly and are very obvious.

I can sympathize with somebody who has largely worked with untested statically typed projects and has moved to untested dynamically typed projects though - this is where the benefit of compiler type checking might seem to be most valuable.

I can also sympathize with somebody working with a dynamically typed language with a bad type system (cough javascript).

>In my experience the extra up front overhead (in terms of development time) of static typed AOT compiled languages end up saving you development time in the long run

Yeah, mine doesn't.
This is a problem since printed books exist.

There are lots of different options:
https://en.wikipedia.org/wiki/Widows_and_orphans#Guidelines

The kindle also doesn't support proper kerning. Sorry if I told you that and you can't unsee it now.

But you can install 3rd party reading software on jailbroken kindles like koreader that fixes some of the deficiencies.
The US buttons don't work because there are mandatory waiting times for the doors closing due to the ADA ((your article mentions that)) - they're still normally plugged in.
Can you please explain this whole American "affirmative action" and "special hiring practices" thing? As I understand it, when given two candidates with equal interview results, the company will choose the female instead of the male one. Am I getting it wrong?
I sense traditionalist bullshit.
One thing people don't think about with some of these optimizers is that it will strip color profile and all metadata. The caveat here is that you can lose color accuracy/range for the former, and vital licensing information for the later.
Why does it make non-production workflows difficult? You could do many things for non-production environment. Use a different bucket for development, abstract the generation of the url away so local development just uses another url to upload to yourself.
Christ. Nary a day goes past without me learning about yet another malign 4chan incident. To think I used to find them amusing.
> Note that I've not written any significant code in either language, so I'm just writing based on what I've learnt by reading.

So he’s basically comparing 20+ years of Python usage with marketing material from Go and Rust. Right.

I wish people could be honest with their motivations, instead of making up excuses to justify this sort of change. Here it’s a classic case of “I got bored and I don’t like the new features, want new shiny”, wrapped in a bit of whining about problems that have well-known solutions (use a good IDE, use type hints or one of the many libs that enforce types...). I have no problem with that, just don’t try to sell it to me on technical grounds, because it looks very much like you have none.

Python is still one of the best ways to get stuff done, quickly and with a minimum of boilerplate. Its limitations are well-known and have not really increased for about 15 years - if anything they have shrunk in many, many areas. Adoption rates keep exploding, despite a lot of doom forecasted by some alpha geeks about 10 years ago: “There is no mobile story! We will all be using Ruby/Go/NodeJS tomorrow! Nobody will ever go to Py3!” Etc etc etc.

You got bored by it? That’s fine, it happens, no harm done. But you don’t need to convince anyone, including yourself, that you’re moving on because of this or that flimsy excuse.
Grandparent didn't claim that bad sleep patterns occur only to parents. He claimed that all parents have experienced bad sleeping patterns.
There is a flaw in your proposal: Deinstalling doesn’t necessarily ensure all program data is removed (at least on desktop OSes). When you reinstall the program, your previous program data can still exist and be used as is. So the persistent cookies can actually be super persistent in that they survive the program removal.
Agreed. One of the most interesting and challenging projects I worked on was a stratigraphic suite of programs used by a mining company. The programs had been written over a period of about 15-18 years by numerous persons of varying knowledge and ability. In doing maintenance coding and writing the missing documentation I learnt heaps about geology and mining practices.
It's the same with Greenwald. I read him regularly. I'm pretty sure ideologically and politically he's a totally standard left leaning journalist, but he is willing to attack anyone if they're being inconsistent regardless of political affiliation, and he's been covering journalistic dishonesty for years now. There are good reasons the apparently rather libertarian and conservative Edward Snowden went to Greenwald with his story and not the many more mainstream alternatives.
If the cookie is stored in-file somewhere you could probably make a batch file to delete it and then start chrome and put the shortcut on your desktop and in your start menu.
Perhaps you should use Firefox.
If they are the fancy types (not city) and not broken then it is going to be good. Broken lights generally indicates neglect and crime.
That doesn't sound like a particularly convincing reason. In order for mobile devices to benefit from HTTP/3, commonly used HTTP client libraries will have to be updated. Which usually happens on a similar timescale as kernel updates anyway.
Ooh, nice! Been waiting for this for a while; now I can finally change my terminal's theme automatically when the system appearance changes: https://gist.github.com/saagarjha/9a99ed4bc68a37bab097cc6ee8...

Although, I clicked through the status bar stuff and now I can't figure out how to get it back :(
We tried using KaTeX for https://www.arxiv-vanity.com but unfortunately it doesn’t support a lot of commonly used stuff. I forget what most of that was now... over/underbrace is one I recall.

In the end we used MathJax pre-rendered on the server, which is the same speed as pre-rendered KaTeX: https://github.com/mathjax/MathJax-node

We’ve also done lots of tweaking to make it support as much stuff on the arXiv as possible. Our MathJax config is a fun read: https://github.com/arxiv-vanity/engrafo/blob/master/src/conv...
ImageOptim is great. The amount of bytes it has saved me over the years is staggering.
Those are processing crimes. And Stone denies the accusation.
>This puts downward pressure on real estate prices in areas which are unprofitable by increasing inventory and decreasing investor demand for rental property.

Yep, and when this happens it opens up a new market - prior renters who were priced out of the mortgage market before can now become homeowners.

There's no economic law stating that middlemen have to take a large cut.
I believe handling of Flash cookies is completely outside the browser.
Like I said, tests are also subject to user error. I’ve seen scenarios where tests passed when they shouldn’t have because the test itself was wrong. Or situations when test coverage was good but a basic type check seemed so obvious it was forgotten to be added. Some of those tests wouldn’t even have been needed in Rust or Go.

I do agree that tests are important; hence why I raised that point from the outset. But ultimately in Python you’re still having to add extra tests just to catch up with the default behaviour of Go and Rust. Which is the point I was raising. Go and Rust are better at catching stupid user error.

Clearly though you can write large projects in Python if you’re disciplined enough. Same could be said for C, BBC BASIC or even assembly. The question isn’t whether you can, it’s whether other languages makes it easier or not.
I said imply, not claim.
The Rise and Rise of Death Online
They definitely worked on this at Microsoft. I am running the latest insider build at home and compared to my works PC which is 2 official releases behind its way snappier. Start menu pops up instantly, search finally works, the button hover effects don't seem to miss frames anymore.
As a counterpoint, I very much enjoyed the presentation and felt the transitions were well done. I also enjoyed the example videos.
Living in both? Certainly not. However I would advocate visiting Scotland if you’re English. It’s a beautiful country.

Likewise nobody says you need to be a full time developer in every language to get benefit from learning them.
From what I hear it is very expensive to live in Paris unless you are willing to commute from the suburbs. Then again, people working in all the major cities complain about the same thing.
I'm going to have a go with Rust and Go too, but for different reasons.

IMO Python is still the best language to go with when you are writing anything "scripty":

- Stuff that's not expected to be long. Do one thing well, let some other program do another, compose the higher order functions from functions that work. Of course this isn't always possible.

- Stuff where the types are not going to confuse you. Often you just have a few types, and it's fairly obvious what you can do with a given object. If you get too many types, there's a good chance it will start to get confusing and then strong typing would help.

- Stuff where performance is not a problem. Don't write your HFT system in Python. You simulation though, might benefit from orchestration of some VMs.

The ultimate use case for Python is glue code. And guess what, a lot of code is just glue. A good glue language has a large ecosystem of libs, and some language features that make it easy to read. That's Python in a nutshell: whitespace formatting makes things easy to read, and you get built in list/dict syntax to keep everything short and sweet.

For me Rust and Go are interesting having come from C++. There's a lot of pitfalls in C++ that might be helped with Rust. At the moment I have a whole load of Valgrind suite tests that look for potential problems. Perhaps Rust can bake those into the language? I haven't had time to look at it yet.

Go seems to be interesting as a compromise between easy and fast, and by the sound of it things have turned out well. I have people on my team using it, and it seems to be the thing to do for web services that need to be faster than nodejs but you don't want to spend a load of time making sure a c++ version is correct.
This is a great stuff!
Still waiting for Google to add a feature to display a warning alert box when you try to close all tabs by accident, but a decade later no such feature exists even though everyone wants it, and Firefox has it, and it seems trivial to implement.
Exactly this.

Rust is quite the opposite of Go in that regard - just like C or C++, it makes it really easy to write over-abstracted and clever code that is hard to understand, audit or review.

Rust is also an extremely powerful tool and a ray of hope for systems programming, but comparing it to Go is an apples and oranges comparison.
You don't even need AWS SDK to do the generation, you could roll your own. (I had to do that long time ago when doing a Windows Store App for Windows 8 and they didn't support it) If you pull in their SDK it's easier.

One of the benefits to the signed URL stuff is you can actually include metadata in the url which will be attached as attributes on the S3 object.

For example i had a UI which would allow user to enter data for a photo they uploaded. When they hit submit it would save the data to the database and return a signed url. The signed url would contain the id to the id of the record in the database. Then when the file was uploaded to s3, i could raise an event into a Lambda, and that would give me the attributes to the record in the database. So I could process the image for a thumbnail then ping a url with an update for the file. And never need to 'figure out' which record in the database it belonged to. The user cannot change the id because the id is signed as part of the requested.
Direct link to the project: https://www.gjopen.com/
No one likes the SAT. It’s still the fairest thing about admissions
Colour 0.3.12 Is Available
As a driver and infrequent cyclist I’d say the reason cyclists are irritating is because they’re not as predictable as cars or motorcycles, and they’re also way more fragile. When one is around I have to keep one eye on them the whole time to make sure they have space.

One thing I would change is to mandate proper turn signals on bicycles. Some people aren’t good at hand signals, and you have to take your hand off the brake to make them, which just seems ludicrously unsafe to me.
We just did this for our own SaaS. Our backend is Django and we use djstripe[0] to connect to Stripe.

The model is as follows:
A user pays per site (he can add multiple) and we decided to have all features available to all plans except for pageviews (we supply a search service like Algolia, but better ;-), and a notification service (small persuasive popups) for e-commerce).

We tie a so called 'module' to a site. A module has a product, start date, end date and subscription (FK). When a user signs up he can start a trial for a specific product which in effect creates a module with a start date, end date (now() + trial_length) and an empty subscription (ie. no subscription means trial).

In our middleware we check if a user wants to view a specific page from a product and we allow/deny access based on having a valid trial (now < end_date). We have jobs running that check which trials have ended and we suspend serving the javascript (which you need to have the service on your site).

After the trial we redirect to a plan picker (but you can still see reports for instance) and let them choose a plan. All plan meta data comes from Stripe as single source of truth (it sits actually in our db because dj-stripe has cached that using sync and webhooks).

Choosing a plan does the whole CC flow and when we get an OK from Stripe we attach a subscription (payment tied to a plan) to the module and delete the end_date. We set the limit in pageviews and check on the usage every minute using a job. The current usage is also communicated to the customer.

The same check we did with the trial is in place to see if a customer has an active subscription (now < end_date) and if the current_usage < usage_limit.

Upgrading and downgrading is easy: tie a new plan to the subscription and Stripe handles the rest (prorate, new invoice).

Canceling is easy as well: cancel call to Stripe, get the returned end_date and set this on the module.

You also have to think about reactivating the subscription (before the cancelled subscription has ended).

A fews things to consider:

- VAT: we're based in the Netherlands, so we have 4 (2x2) cases: Individual/Company and EU/Non-EU. Based on that we have to charge or charge no VAT, you have to add that yourself in your call to Stripe.

- Expired CC, declined payments: Stripe calls a webhook and you have to handle that in a way that it will (a) change the subscription/module (b) tell the customer

Our model also allows for:

- old/defunct pricing plans by setting the subscription to an old plan

- different/special usage limits for clients using special plans

- payment without CC (e.g. bank transfer) by using out_of_band option on Stripe

[0] https://github.com/dj-stripe/dj-stripe
> Here it’s a classic case of “I got bored and I don’t like the new features, want new shiny”, wrapped in a bit of whining

This seems to be a rather shallow reading of the blogpost, and the way you phrased your reaction is not exactly polite either. If anything, the "adoption rates" of Python (like those of ECMAscript, a language of a similar vintage all-things-considered) are most easily explained by non-technical factors, so I have quite a bit of trouble making sense of your comment.
Thanks for the warning! To elaborate, I have come to understand that code is just a part of the paper, seldom the beef. I basically create proofs of concepts, which I've told increase the impact of the paper (thus be fine to work on). I find that in general, it's not about how much or elegant code I write, but whether it allows me and my peers to learn new.

Industry labs are a good point, but I think I have to consider those later when my academic profile is stronger. Beyond Google X, do you know other options?

And I do have the burning question, which is the end-goal mentioned in the OP.

Thanks for the comment, I feel like there's a pressure for me to create a startup (market validated, employees and funding found) but I feel like academia is actually what I want. Your points solidify those thoughts.
I'm currently migrating a similarly sized Python and Django application to Go but for different reasons.

For me it's bit rot. My Python is approaching EOL on this version and needs upgrading to Python 3, and I have a lot of 3rd party code in here that made things simpler to create but over time they've changed enough or disappeared that I now have to take on work there too. Then Django and it's internals have changed a lot in the last 6 years.

My Go code written at the same time (6+ years ago) hasn't had any of it's libraries change so much that I've needed to do anything. Every now and then I pull the next major version of Go and recompile and it's done.

This is all side project stuff but a lot of people use it (monthly average visitors being +250k)... it's non-profit and I don't wish to have to maintain it much.

It worked once, if nothing has changed in the functionality it should keep working... but this isn't as true in non-compiled languages where you need to depend on so much of the environment, let alone build culture that doesn't fully vendor dependencies.

I like Python, but prefer to write code and move forward with other projects.

As to Rust vs Go. I code in both and only picked Go here because a lot of the code in another project I worked on can be used here. I'd probably try Rust if I was starting from scratch now. But I'd be a little concerned bit rot would affect Rust too, it's still quite early for the wider ecosystem.
Nobody suggest having a "prediction reputation" that keeps track of the quality of people's predictions? Like, after the even should have taken place, open it up for up/down votes or such?
FYI - http://sijinjoseph.com/programmer-competency-matrix/
C++ versions are never correct
Much easier to update an app and its HTTP library than mobile device kernels. Particularly given how a large proportion of mobile devices are unsupported and won't get kernel upgrades any more.
Some comments have suggested that the money needs to come from somewhere / business/staffing is still business, and/or that donating could be done in several ways.

Could you turn these two threads into two birds to kill with one stone? I'm thinking perhaps instead of donating to a 3rd party charity, are you able to perhaps do something like a training and internship program for disadvantaged candidates, be them career switchers, vets, non-college graduates, basically people that slip through HR-nets, with your clients where to get the clients on-board your people into post-training junior experience-building roles for a few months (no or minimal fee for client, you pay a retainer salary to your people) then after 3 or 6 or 9 months if the client wants to retain them you get a lump-fee (and perhaps they stay on your books as an agency too).

Sorry, just thinking aloud. But something like the above seems not only to be a one-off killing two birds with one stone, but might be a sustainable model depending on how you get client buy-in.
It's weird that this got downvoted, because in every thread about images of child sexual abuse there's always one or two people, and usually different accounts, saying exactly this. They'll claim that it's ridiculous to outlaw a series of bits, or that the abuse has already happened and so how can these children still be affected by the images. A bunch of arguments are very similar (perhaps unknowingly so) to arguments made by organisations like NAMBLA.

It's easy to find these comments:

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

https://news.ycombinator.com/item?id=5486398#5487425

This whole thread is fucked up: https://news.ycombinator.com/item?id=5825087

A bunch of comments in this thread: https://news.ycombinator.com/item?id=4495914#4497226

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

There are literally hundreds of comments on HN from a range of accounts defending the posession of images of child sexual abuse.
Yes! Particularly the Underwater-Level-Tracks.