HN user
I’ve recently been trying to get models to read the time from an analog clock — so far I haven’t found something good at the task.
(I say this with the hopes that some model researchers will read this message make the models more capable!)
Hard to beat jib (https://github.com/GoogleContainerTools/jib/tree/master/jib-...) for minimal Java OCI containers.
Thanks for sharing the NFT-as-access-token example, it's far and away the strongest example of a relatable use for NFTs that I've heard, and is compelling both in its value to the issuer (as a verifiable access token) and to the buyer (for both immediate use and due to its resale of residual value after having been used).
I imagine that your friend's NFT contract stipulates he gets a cut of resales, but I'm also curious if/how your friend deals with potentially bad actors that, say, scrape the entire content then resell the token for most of what they paid for it having extracted the content it unlocks. Obviously the contract could help offset a part of that trade, but seems tricky nonetheless?
Edit: I suppose part of the premise is that there are only 500 passes and content continues to be produced, so if you want access to the current library after all passes have been used trading the pass is actually a key attribute of others gaining access to the content.
They’re most common on Thursdays but increasingly appear on Wednesdays, too. Sunday is typically the “big” puzzle day, and has a titled theme that usually provides a hint to at least some of the clues, or the puzzle aspect.
Linked in response to a question I asked below, it seems like you can use CloudFlare Workers to host a static site: https://developers.cloudflare.com/workers/platform/sites
But also, from reading the Pages docs I wager you can also make the build command something like `echo done` and then set the build directory in your configuration to be `.`.
Maybe? It’s more that I’d like to pay for the managed service of hosting my assets, registering branches for long lived access URLs, getting preview links, and promoting my site to its latest version.
Differently: why are Cloudflare and others interested in running my build?
I’d love to see a version of this (or Netlify, Vercel, etc) that didn’t bundle CI with the preview and deploy steps so that I can pick my own CI and then effectively use the “CDN” as the highly qualified host of my static assets.
Ira Glass is the creator and host of a long running radio show called This American Life on National Public Radio. The show runs weekly and tells stories of Americana and other things. I suspect part of what makes the show famous is that it coined not just a particular kind of show, but a particular kind of sound, editing and production, that, I’d say set the standard for modern audio programs.
Several of the shows producers (and Ira’s mentees) have gone on to create other famous shows:
- Sarah Koenig created Serial, one of the first truly mainstream podcasts (1M listeners in its first week) for telling, in the first season, the story of a murder of Haymen Lee and investigating whether the man convicted, Adnan Syed, was likely innocent.
- Alex Blumberg created Planet Money, a short radio show that explores economics and explains it by looking at what’s happening, culturally, around the world. Later, Blumberg founded Gimlet, a podcast company that recently sold to Spotify for $100M, ostensibly to create content with that, now famous, NPR _sound_. Some of the bigger/more famous work from Gimlet is Startup (now also a TV show in the US), Homecoming (now also a show on Amazon Prime Video), Reply All, and Conviction.
Anyway, Ira Glass has hosted This American Life since the beginning, and Blumberg recently interviewed him for a show Gimlet produces called Without Fail. If you’re looking to understand his impact in this space, I think that’s a wonderful place to start.
*edited to correct where the Homecoming TV show airs.
The deployment infra constraints mentioned in parent post are generally managed by tooling we also publish[1]. The encoding ends up similar to Helm’s, but happens through this tooling just by virtue of taking a dependency on a published jar, npm package or conda package, and that removes a lot of programmer error/guess work/maintenance. (I think we’d be open to also emitting Helm’s formats in our packaging tools, if that’s interesting to someone reading this feel free to open an issue on our repo and reference my post.)
Our systems look more wide than deep, and the breadth happens both in FE and in BE, so our diverse FE apps communicate with a relatively diverse set of BE services — we’d like those interactions to look unified no matter where you hit the system. In other words: we have a large number of microservices without a consolidating middleware.
Compared to other frameworks, Conjure more easily retrofits into HTTP/JSON service boundaries (no surprise based on its origins) and, IMO, provides great ergonomics for mixed FE/BE teams, especially where FEs are big and complex with lots of BE interaction.
In terms of audience, we’d hope this helps FE/BE teams with easy to use and ergonomic API defs, and think, as above, it’d especially help others who have existing surface area to convert to declarative APIs, even if only as a stepping stone.
On the BE/BE comms point: we use Conjure for all RPCs in our systems — while JSON is obviously not as compact as Protobuf or Thrift we’ve found serialization and transmission are rarely bottlenecks, and that, instead, a unified format and common treatment for clients is a boon for operability and stability — and often times also for aggregate system performance.
Two big motivations for us: (1) we had a large footprint of JAX-RS annotated Java services and a correspondingly large footprint of Typescript frontends communicating with those services, both hand-maintained; (2) we wanted something that felt just as native and ergonomic in browsers as it did on the backend.
Migrating from that setup required first having a declarative API format to translate through, and Conjure was our answer (starting in 2016) to generate human-quality code that would drop-in-replace our hand-maintained, language-specific client and server definitions.
That said, we're fans of gRPC/Protobuf and heavy Cassandra users (so also have a good breadth of experience with Thrift), and gave both serious looks before getting going, and again before deciding to open source our work today.
When we started on this tooling there really weren't great gRPC options for the browser, and the balance of our developer pain was around frontend/backend rather than backend/backend RPC. We also took a long look at Swagger/OpenAPI, but ultimately moved on because it focused more on the full coverage of any kind of HTTP/JSON API and as a result was too general to end up with consistent APIs across many services.
Over the last two years of development (and conversion of all our hand-maintained clients) we found that Conjure held a lot of value as an easy-to-adapt declarative definition format, that it applied strong enough constraints so as to make API development focused on the semantics and behaviors rather than the syntax or specification. And, we thought that that had sufficient value we should open it up to others.
Beyond that, we've got some work underway to use protobufs as the wire format, and enough flexibility built into the framework that we can use that or other non-JSON wire formats along-side JSON with the same client and server interfaces and code implementations.
I'm one of the authors of this project -- happy to answer questions!
Conceptually this seems to be a Java approach to Railway Oriented Programming (http://fsharpforfunandprofit.com/rop/), which is pretty sweet.
One of the teams I work closely with used JGit's extensibility to run git on top of a KVS: https://medium.com/@palantir/stemma-distributed-git-server-7...
Notably this doesn't require a distributed filesystem.
It might be worth a look at Immutables (http://immutables.github.io/) or FreeBuilder (https://github.com/google/FreeBuilder), both of which also use Java's built-in annotation processors to do code generation, but involve slightly less magic and produce generated classes which are not overwriting the original class.
I was curious about the new features and the description on the core site was pretty helpful...possibly useful for others to save having to search:
Yeah, read/write conflicts don't seem to actually generate conflicts. e.g. imagine two processes p1 and p2:
p1: SET a 1
p1: BEGIN
p1: GET a
p1: SET z 1 # imagine this were contingent on reading a
p2: BEGIN
p2: SET a 2
p2: COMMIT
p1: COMMIT # expect conflict, but don't get one
p1: GET a # returns 2
p2: GET z # returns 1Yep, typo, 16 not 26.
Fun trick: turn your phone to landscape mode while in Calculator and you get 26 digits instead of 9.
What tool do you use to emit the typescript interfaces? I looked around for one of these a few months ago but didn't find anything at the time.
That'd be essentially the same as Slingbox (http://www.slingbox.com/).
It seems like it's part of Netflix's data pipeline, Suro[1].
[1] http://techblog.netflix.com/2013/12/announcing-suro-backbone...
Notably absent from your list is http://grepcode.com -- which IMO has one of the best interfaces around, with compiled code docs and some java-centric implementation and invocation links for java code they index.
What's the raw scale of input data for your 300GB/day of stored events? (assuming that's 300GB on disk stored in Elasticsearch)
Interestingly the chart at the end suggests implementations for everything except the raw data, but generating batch views from an arbitrary store and keeping your raw data reliably are hard problems. The charts motivate dumping this stuff in Hadoop (or some distributed file system), but any reliable store would do. (@nathanmarz: would love recommendations)
The problem with comparing Hulu to cable is that with my cable subscription I'm free to record shows and play them back later - without the ads. Similarly, the on demand content rarely includes ads, and when it does they're sparse and extremely short.
I often find myself starting to watch live tv shows about 20 minutes late and playing it as it records so that I can see the show the night it airs _and_ avoid ads.
When Hulu will let me do this, I'll drop cable. (that said, I realize the premium I pay for these privileges and others with cable is steeper than it should be)
Maybe there's another page where you can submit the samples and this is the presentation/identification ;-)
The trivial example of PHP is equivalent to making a file with only the text:
Hello World!
In reality, one of the things that makes PHP an easy language to pick up is that you don't have to have all of the overhead of learning how it works. Novices sprinkle bits of PHP surrounded by HTML-looking tags and all of the sudden they're up and running.
I started with PHP myself, and found it to be an interesting and frustrating language (needle or haystack argument first?). It's often saved by an easily searchable manual and a huge user base.
PHP is a shoot-yourself-in-the-foot language. It'll happily let you do dangerous, awful, bad, bad things. This wouldn't be such an issue if there was a higher barrier to entry, the real problem is it's easy to pick up (is that really a "problem"?), but that's a feature not a bug.
One thing I think would be valuable to know here is how many threads each shard is using, and what effect changing that number would have.
(rather: why is it useful to explicitly shard vs running one big instance with all of the memory and the same total number of threads? queuing theory would lead me to believe the latter would be better)
Link NASA's GitHub page: https://github.com/nasa