skysight-inc/HackerNews huggingface dataset:
This may fill the hole that Pinafore might leave for some (it just became unmaintained and it's not clear who will pick it up).
UBI will never pay what a government job pays in purchasing power; that part is just math I think.
I would assume they didn't made all those billions by running unprofitable shops, didn't they?
Debugging in this case, i mean, i can inspect all program state, variables step by step, and i don't care much about "result" or "output".
Stores have thought of this, and know the effects already. Apparently putting products behind glass causes almost a 50% drop in sales( because people don’t want to bother), so stores would prefer not to put anything behind glass or a counter, but they do because the alternative is 100% loss from theft.
Between the high level architecture diagrams which don't change much and the code itself, it feels like we are missing a strategy or tool for visualising mid-level code structure which is in between these two ends of the spectrum.

At work we have a bunch of Python services which do REST API and CRUD for the most part. There we have a simple plain python dependency injection set up which puts together the different components/classes of service and makes sure that each is provided with the references its dependencies. This is defined in one python file. I experimented with parsing this file and graphing the relations between the components, and the result was pretty good (given my low effort). It did a good job of exposing the relations between most of the important classes and where things had gotten messy.
code with output that can only be evaluated artistically can't be called right or wrong anyway. As long as it throws no errors, it's a valid language model. I can only imagine how many nulls and undefineds and Infinitys they just throw out and shove under the rug. That's actually the kind of code where not knowing how it works is okay. Encouraged, even.
It seems like did change the business model - they decided to close shops in unprofitable locations.
I think what they've done is implemented a way of doing snapshot testing by putting the snapshot data in the test itself. In snapshot testing you just cache the result of a code block and use that cached data to check the code produces the same output as it did when you knew it worked. Putting the snapshot inline in the test makes it a lot easier to read.
What has happened is that services offering medium scales production has become quite a lot more accessible. One can get a quote by uploading to online form, no need to enter a long term supplier agreement, few restrictions on minimum order quantity, and the starting points of prices is lower that before.
And the 3d printer is key tool in prototyping the solution, and validating the design before sendibg off. It greatly reduces the risk of spending money manufacturing the wrong thing, or in wrong way (design issues).
A modular system for isometric pixel blocks
Far more than 99% of ‘experts’ in 1400s Europe considered the Sun to revolve around the Earth.

Appeals to popularity have obvious pitfalls.
I use cmd+tab and cmd+`, no issues figuring out what has control over what.
AMD RDNA3 ISA Reference Guide Published
private care exists in the UK.
Ah. The classic "decentralization on top of Cloudflare" that is already common throughout the fediverse brought to a new extreme.
Is there anything on gemini other than people talking about gemini? Not trying to be facetious but last time I looked I couldn't find anything. I'm sort of directionally sympathetic to their goals so I want it to be a case where there is great stuff there that I just didn't know how to find.
You are prepared to fight the system, while you don’t know why it is doing what it is doing and what you are gaining by fighting.

Your arguments are mostly ‘I’m used to Windows doing X so that’s what I want on the Mac.’ If you want Windows, use Windows, that’s a lot easier than trying to get Mac OS to be Windows. It’s not Windows, if you can get used to what it is you’ll have a great time and if not you’ll end up frustrating yourself.
Nice, but... too easy? I lost interest at 20
Very interested in this. Tho I feel a bit sad as I had an idea for this precise product years ago and built some crappy cardboard prototypes but never quite got it far enough along to make anything of it. Understanding optics was something I got stuck on. The "damn, that could've been me if I'd worked harder" feeling stings.

Congratulations to the team. If and when they release an Android version I'll buy one straight away.

Juding by the comments they should perhaps market this more for home use and less for out in public. Still, I think this has the potential to be definitely very fun and possibly very useful.
IMO The real value in tests is making sure you don’t break things later, rather than for getting your current code working.
This is not true. If you cause an unsafe situation, then you are certainly to blame, regardless of other traffic rules that you think may be relevant.
You are right, I thought Shippingport reactor 3 did but it also was a blanket design.

I don't really think this matters that much. The neutronics is pretty well understood and the principle has been proven. Its just a matter of investing the money to do it.
I think it relates to exchange rates.
On 2001 1 US Dollar = 1 Argentinian Peso.
On 2023 1 US Dollar = 185 Argentinian Pesos.

In truth, thing is much worst, because you wont get 1 US dollar anywhere (nor banks, financial orgs, or privates will sell it for that price). On the market is close to

1 US Dollar = 360 Argentinian Pesos.
I believe you are referring to one of the many listed ways to define https://oeis.org/A001105 , which is even more succinctly expressed as a(n) = 2*n^2. This is the answer I thought you wanted, and which I was avoiding saying.

My underlying point is your sequence was under-specified, and with no clear reason to pick your preferred answer over other answers.

Even knowing it's chemistry, three finite sequences which match your specification are:

2, 8, 18, 32, 18, 8, 2
2, 8, 18, 32, 21, 9, 2
2, 8, 18, 32, 32, 14, 2
> but on HTTP(S),

Gemini is fully encrypted

It simply doesn't rely on the same chain the CIA and other agencies own

inline images are left to the client implementation.

Lagrange supports them, for example.

https://gemini.circumlunar.space/docs/tls-tutorial.gmi
I’m not a Luddite but I feel something like schadenfreude watching people give profit-driven companies access to their private lives for solved problems like “cleaning the floor” and “tuning the radio”.
I agree with this in principle and use mermaid quite a bit. I like that code can be versioned clearly to track changes and this lowers confusion over when the diagram changed, who changed it, who approved it, and what changed.

However, I have a hard time with “ugly layouts” that really do distract any attempt to describe the architecture. This comes up a lot with flow charts and sequence diagrams where non-dev stakeholders want to read and understand. Frequently we end up redoing them in draw.io or something that allows a manual layout that looks better.

This is a minor nit, but is a big barrier to architecture as code as once the diagrams get manual, they get out of sync.
When measuring the health hazards of motorbikes/mopeds, emissions are a small part.

Part of the reason is that it's so fun to go fast with them.
With each tool using its own macro-based DSL for managing them. That would be fun
“YAML evangelist” sounds terrifying, and I have never met one in real life. Most people who used YAML basically resorted to the old argument of “Well JSON doesn't have comments, so YAML it is”.
I just found out about warp, installed it and having a similar issue.

Terms are really weird for something I thought was a terminal app, and their commong questions are talking about "cloud-oriented features" which I really don't know and probably don't want.

I'd be happy to pay (even per month) for a version of this that asks you "do you want to use our cloud features or just the local version" and has different pricing and definetely no login.

Note: I didn't end up actually trying this as I really didn't like the sound of not knowing what my terminal is sending out. They do list what they send for telemetry, but not sure what is considered "cloud-features"
Hard disagree.

XML is great for systems to read and write, but utterly abhorrent for humans. It's not just having to close tags. It's content vs attribute confusion, namespacing noise (which are also muddled with attributes), and there's a squint factor incurred by the density of information.
In practice, all RFCs are standards documents.
> Swift<>ObjC bridging

This is another commonly held belief that doesn't hold up to actual measurements.

For an example, see part 2: https://blog.metaobject.com/2020/04/somewhat-less-lethargic-...

All the pure Swift implementations are even slower than the bridged ones, and the bridged ones are slower than the most comically inefficient Objective-C one (using KVC, for example), which is slower than the reasonable Objective-C ones.

> In particular Swift is more memory efficient than ObjC ...

It's not.

> ... because there's less boxing overhead to small values

You would think, yes. I actually did think that as well. Because it really sounds plausible. So imagine my surprise when I measured some common cases for my book (Chapter 9) and it turned that even in the cases where I just knew™ that Swift would be faster, because of this very reason, it just wasn't.

> That should matter more than the overhead from more overflow checking.

Computers don't care what you think "should" be the case, and they cannot be argued into better performance due to plausible arguments and strongly held beliefs.

You need to measure what actually is the case.
indeed, i guess thats what humane is working on.
Yes, seriously. I believe that, on average, my next task is more likely to be in the same application than the previous application.
That is exactly the thought it my head. Linuxbrew just barely works and breaks frequently. I wonder if this would be more reliable. So you can run current tool versions of tools on an older machine.
> All that horrible mess, it seems, because people didn't like to have to close tags.

The issue isn't that it's bad per-se. The issue is that it's cumbersome to write. When you want to setup and tweak a tool, it gets annoying very quickly having to deal with little errors because you misspelled a closing tag. Maybe you want to test enabling a setting? Typing out 4 characters is so much less friction than the 20 or more (including the < > : / characters) you'd need for an XML config.
I think perhaps having their own protocol serve to encapsulate the community interested in this particular form of simplicity.
It’s the learning curve really.

Our industry has the remarkable properties of being almost entirely newbies, a constant churn of green developers, combined with being very bad about passing down generational knowledge. This is why things that are easier to explain win out over things that are technically superior but take longer to get your head around almost every time.

The thing JSON had going for it over XML is that it maps cleanly to most languages object models so you can read the results directly. No writing XQueries or DOMs to read values.

It’s only major downfall is lack of comments, which has lead people to YAML. (There’s plenty of other things it lacks in comparison to XML, like native schemas, but most of that falls into things newbies don’t know they want)

YAML is in this weird middle place where it’s easy to explain but impossible for a human to master. It appears as simple as JSON to newcomers who adopt it, but the long time users of it find it full of foot guns. People wanted JSON with comments but instead they got the complexity of XML minus the clarity.
I wish I was too smart. I'm too dumb. Most of the large projects I've worked on make me feel this way. I hate when I have to look through multiple interfaces to figure out what is actually going on.
I think they are gripes from trying to combine the bottom-up approach of Tailwind with the top-down approach of props based styling that JS component libraries typically allows. His point being that Tailwind does not work too well with such solutions for dynamism / contextual style overrides. You could solve it with using clsx or cva though, as seen in this video: "Tru Narla: Building a design system in Next.js with Tailwind" https://www.youtube.com/watch?v=T-Zv73yZ_QI

The best way seems to be making styling a completely internal component concern, and not take in style props but simply semantic props like isActive=true and then have the component itself apply styles based on that, like NavItem.js on the Tailwind home page suggests: https://tailwindcss.com/#component-driven

This practise is elaborated in this example has the same button styled differently by passing in different semantic props: https://youtu.be/T-Zv73yZ_QI?t=570
That's the town they had to move due to mining, wasn't it? I hope this doesn't mean they have to move it again :)
> This doesn't require that the dismissed application still have control of the menu, however.

You haven't dismissed the application; you've closed or minimized a document. The application is still active.
Would port 443 work for you.
Feel free to join our slack to discuss.

https://join.slack.com/t/pinggycommunity/shared_invite/zt-1n...
‚metals which are essential for, among other applications, the manufacture of electric vehicles and wind turbines‘

Great way to frame mining as eco-friendly haha.
Is my take too skeptical? Are these very specific metals to eco-friendly production?
Funny to read this since based on my testing so far DuckDB is not quite rockstable yet, requires preloading the httpfs module and setting 5 parameters each tun just to query a file off S3 (often very slowly, mostly because of the folder crawling/list logic?) with non standard SQL for extensions and segfaults frequently during testing if the remote server has any unexpected response (also not working too well with S3 clones). The WASM version differs in s3 settings, too but this is not well documented. If you really love opensource and with such a long career you should know there is no point in badmouthing other projects in order to achieve success, particularly from leadership positions. Just make DuckDB great and let happy users speak on your behalf. Nobody wants to be part of a toxic community this early in.

I do NOT work for ClickHouse, but I've been running super stable distributed CH clusters for years.
>There is a mainframe in each store
Nope. vSphere clusters in every store. Possibly the biggest ‘field’ footprint of vSphere that exists.
INI has no spec, and there are many variations all slightly incompatible with each other, kinda like Markdown. YAML is really the only sane configuration language that lets you denote nested structures while keeping them look nested.

Basically, all of the problem identified in the article can be dealt with 1 rule - always quote your strings. I agree with the author we should have reduced, safe and minimalist subset of yaml, which is basically YAML 1.2, released in 2009.

P.S. Please just stop using PyYAML.
On earth advancements in technology, education, and especially woman's rights quickly lead to reduced or even negative population growth. So maybe interstellar civilisation won't need that many space cities
Regular engineers are paid 100k, senior engineer 150k

It's on their site
Who needs dowsing rods when you can just move a town and see where it goes to find the next big deposit.
wow this is great news, the Earth keeps surprising us with its riches!
Shouldn't have to, the rare earth minerals are in an area already designated for iron extraction. The new metals are just a nice bonus, I suppose.
That doesn't get the undesired application off the screen.
The CFG configuration format is a text format for configuration files which is similar to, and a superset of, the JSON format. It's not new - it dates from well before its first announcement in 2008 - and has the following aims:

* Allow a hierarchical configuration scheme with support for key-value mappings, lists and basic types such as strings, ints, floats, Booleans and date/times.

* Support cross-references between one part of the configuration and another.

* Provide a string interpolation facility to easily build up configuration values from other configuration values.

* Provide the ability to compose configurations (using include and merge facilities).

* Provide the ability to access real application objects safely, where supported by the platform.

* Be completely declarative.

It's similar to newer formats such as JSON5, HJSON, HOCON and similar but offers a number of features [0] which they don't, as indicated by the above list. It's not intended to occupy the niche where you find things like Cue, Jsonnet, Dhall and similar.

It was just never especially publicised when first implemented for use in Python projects, but it now also has implementations for the JVM, .NET, Go, Rust, D, JavaScript [1], Ruby and Elixir (all BSD-3-Clause licensed) and it would be great to get feedback on the project from the HN community.

[0]: https://docs.red-dove.com/cfg/intro.html - description of features and comparison with other similar systems

[1]: https://docs.red-dove.com/cfg/playground.html - uses the JS implementation to create an interactive playground
Related and interesting consequence of mining in the area, they're moving the entire city of Kiruna (~22k inhabitants) because of the expanding mining operations: https://www.forbes.com/sites/davidnikel/2021/03/23/kiruna-a-... - http://edition.cnn.com/style/article/sweden-kiruna-relocatio...
Kiruna has a long history about mining incl world war II importance for iron.

Also due execessive minig the whole town needed to be moved:

“In 2004, it was decided that the present centre of the municipality would have to be relocated to counter mining-related subsidence.[29] The relocation would be made gradually over the coming decade. On January 8, 2007, a new location was proposed, northwest to the foot of the Luossavaara mountain, by the lake of Luossajärvi.[30]“

https://en.m.wikipedia.org/wiki/Kiruna
I mean, hospice knows roughly when someone is near death because when you remove care, the patient basically starves, and that generally follows a pretty clear progression.

It seems like the hard part is making sure people have had the conversation. If I'm over 80 years old and can't communicate or feed myself, I'm not expecting much of a recovery. I think a lot of people would acknowledge that if they were asked to think about it.

(of course there are lots of situations where a good recovery is pretty likely, but hopefully the doctors aren't waffling about what to do in those situations)
I miss the old days of working with XSLT and XPath. A nice way of giving some design touches and filtering/sorting to XML documents. It wasn't perfect but I would take any time over the yaml/json/toml/ini.
To misquote the author of Solid.js as I remember it:

--- start misquote ---

There's no wonder react has been popular for all this time. We needed a time of relative stability and gradual evolution. We don't need revolutions every year.

It gave time to think about hard problems, and come up with new solutions. There's intensive work being done right now on things like proper partial hydration, SSR, granular reactivity etc.

--- end misquote ---

This is partly reflected in the graphs as well: react dominates, but "new kids on the block" like Svelte and Solid have insane rates of interest and retention.
This is a pretty good summary. In my experience those people don't understand other's POV, because to them, their solution is not complex. They can be valuable short-term but do a lot of damage long-term, as their goal and yours are not aligned - they are very selfish in that they want to solve difficult puzzles instead of helping the customers or improving the team.
"I believe that, on average, my next task is more likely to be in the same application than the previous application."

So what?
Wonder what the practical implications of a million tonnes is? For industry, is a million tonnes really that much?
> If we look at how other permit processes have worked within our industry, it will be at least 10-15 years before we can actually begin mining and deliver raw materials to the market.

Meh ?
ARC's problems are orthogonal to tracing/copying GC's problems. They are fundamentally different paradigms, since ARC mostly pays a cost for memory which is no longer in use, while tracing/copying GC pay a cost for memory which is in use.

That is, with ARC, the more garbage you generate, the more work will be spent on the GC vs normal program flow. In contrast, with tracing/copying, you can generate as much garbage as you want, without affecting GC time; but, the more memory you actually use, the more time you will spend in GC.
Why startups should develop in Clojure in 2023
On a tangent…

I’m currently losing the will to live with integration tests for an http service I’m writing.

It calls out to other services (often 3 or 4 external api calls for each of my http resources, each with complex data structures).

(I just want the external API data in a database!)

Tests are a pain because of the matrix of fixtures needed. My API endpoints behave very differently based on the attributes of the objects in the response from the other APIs. So I have lots of somewhat complex code to generate fixture data, which again is another source of error and a whole lot of code.

For one of my endpoints, I have to mock 1-6 API calls, multiplied by 3 or 4 variations of the returned data. It’s torture.

None of my tests are that obvious what it’s testing because the fixture code and json assertions are so big and long.
We aren’t using an http mocking lib right now (eg wiremock) but I’m wondering if it’s worth it.

I guess a lot of it is because the APIs I’m calling are so badly designed.
I'm 191cm and often can't see the far side signals in a normal seated position in a Civic. If the signal heads were on the near side, I would have to stop like three car lengths away from the intersection to see them from inside the car.

Re: bike lanes, I think it they need to do more to distinguish bike lanes from just extra pavement beyond the white lines. There should be a different color line to make it clear to expect bikes there and not to use it as extra margin if the oncoming traffic is close to the line, etc.
I think if you're working alone or on a small team on a small project it's use is negligible. The added tidium may not be worth it, and many major issues can be shaken out with integration tests, QA and users.

I think a lot of people miss the (in my opinion) best use case for UnitTests. It's in-code self-documentation. Leaving a little nugget of your understanding of the functionality behind for other developers in the future. Even if a method is horribly named or the business logic is so complex it takes an hour to understand exactly what is happening, a simple group of (input -> method -> expected output) unit test can get you working with the method fairly fast.

Actually, if I am extending a giant god function that is un-tested. I find it exceedingly helpful to add some tests for the specific use cases I am adding, just to be sure I have understood the code path relevant to my change correctly.
The company that owns the mine LKAB are together with swedish Steel producer SSAB producing fossilfree steel. They are working with Volvo to build their electric cars with this steel https://www.ssab.com/en/news/2021/08/the-worlds-first-fossil...
Pretty sure they'd be destroyed if they did that shit in EU
> Templating yaml is a terrible, terrible idea

I've had a good time using ytt: https://carvel.dev/ytt/. It implements language-aware templating, which is IMO the only reasonable way to do it.
International Space Station Operations, Soyuz Status Update