id
int64 2
42.1M
| by
large_stringlengths 2
15
⌀ | time
timestamp[us] | title
large_stringlengths 0
198
⌀ | text
large_stringlengths 0
27.4k
⌀ | url
large_stringlengths 0
6.6k
⌀ | score
int64 -1
6.02k
⌀ | descendants
int64 -1
7.29k
⌀ | kids
large list | deleted
large list | dead
bool 1
class | scraping_error
large_stringclasses 25
values | scraped_title
large_stringlengths 1
59.3k
⌀ | scraped_published_at
large_stringlengths 4
66
⌀ | scraped_byline
large_stringlengths 1
757
⌀ | scraped_body
large_stringlengths 1
50k
⌀ | scraped_at
timestamp[us] | scraped_language
large_stringclasses 58
values | split
large_stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
42,036,416 | jMyles | 2024-11-03T22:00:57 | Ask HN: I accidentally left a microfiber cloth in a pot of greens – safe to eat? | My neighbor and I made a pot of greens last night. We've eaten about 1/5th of the pot, and just noticed that we left a microfiber cloth (87% polyester and 13% polyamide) in the pot while it simmered overnight at low temperature.<p>I brought it to a brief near-boil (setting 8) for 3 minutes, then it simmered on a setting of '2' for about 4-5 hours, and then a setting of '1' for 4-5 more. Well below boiling.<p>I took it out of course, but now I wonder: is it safe to eat the rest of the pot?<p>I realllly want to eat it; it has yummy local collard greens, turnips, and pasture-raised pork. And it's delicious.<p>My best guess is that it wasn't really hot enough, for long enough, to create a level of exposure that's a measurable health risk in one pot of greens.<p>But if there's somebody here who works frequently with these materials (or who has recently refreshed themselves on the available evidence), I'd love to hear empirical thoughts. | null | 2 | 6 | [
42036883,
42036508,
42037851
] | null | null | null | null | null | null | null | null | null | train |
42,036,429 | amichail | 2024-11-03T22:02:50 | Ask HN: Why don't novelists want to achieve immortality via AI writing as them? | By this, I don’t just mean that AI would write novels in their style, but that it would also take into account all their novels, life experiences, interests, knowledge, and current events. | null | 3 | 15 | [
42036862,
42038747,
42036716,
42037848,
42036549,
42036448,
42036529,
42039468
] | null | null | null | null | null | null | null | null | null | train |
42,036,440 | PaulRobinson | 2024-11-03T22:05:06 | The different content TikTok and X showed an undecided voter | null | https://www.bbc.co.uk/news/articles/cy5lngzxxrvo | 12 | 8 | [
42036958,
42037030,
42037011,
42036870,
42036833
] | null | null | null | null | null | null | null | null | null | train |
42,036,449 | cbuwu | 2024-11-03T22:07:05 | Sastsweep: Automatically detect potential vulnerabilities and analyze code repos | null | https://github.com/chebuya/sastsweep | 1 | 1 | [
42036450
] | null | null | null | null | null | null | null | null | null | train |
42,036,476 | AbuAssar | 2024-11-03T22:11:08 | GJS: Node.js Like Runtime for Gnome | null | https://gjs.guide/ | 45 | 15 | [
42053945,
42040093,
42040671,
42040651,
42039634,
42042577,
42040714,
42039149
] | null | null | null | null | null | null | null | null | null | train |
42,036,484 | puttycat | 2024-11-03T22:11:42 | Ask HN: Why did AI research mature in computer science and not in biology? | null | null | 5 | 3 | [
42041554,
42037294
] | null | null | null | null | null | null | null | null | null | train |
42,036,515 | productprof | 2024-11-03T22:15:12 | X was supposed to be a bank by now | null | https://www.theverge.com/2024/11/1/24285681/x-elon-musk-everything-app-bank-fail | 34 | 12 | [
42036947,
42036778,
42036726,
42036578,
42036602,
42036605,
42036894
] | null | null | null | null | null | null | null | null | null | train |
42,036,520 | doener | 2024-11-03T22:15:42 | Electric vehicles now represent 19% of the passenger vehicle sales worldwide | null | https://twitter.com/janrosenow/status/1853182692868973025 | 27 | 46 | [
42037244,
42037357,
42038997,
42037733,
42038264
] | null | null | null | null | null | null | null | null | null | train |
42,036,525 | rbanffy | 2024-11-03T22:15:58 | Nice Performance Gains with SVT-AV1 2.3 Encoding on the System76 Thelio Astra | null | https://www.phoronix.com/news/SVT-AV1-2.3-ARM-Performance | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,536 | pseudolus | 2024-11-03T22:17:59 | The Secret of Ramsey Numbers | null | https://cacm.acm.org/news/the-secret-of-ramsey-numbers/ | 47 | 7 | [
42040702,
42045097
] | null | null | null | null | null | null | null | null | null | train |
42,036,539 | PaulHoule | 2024-11-03T22:18:18 | "It's just like plugging in your phone": The mindset shift needed to scale EVs | null | https://bigthink.com/the-present/ev-mindset-shift/ | 3 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,545 | rbanffy | 2024-11-03T22:18:56 | TSMC rumored to receive High NA EUV machines from ASML this year | null | https://www.tomshardware.com/tech-industry/semiconductors/tsmc-rumored-to-receive-high-na-euv-machines-from-asml-this-year | 8 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,547 | rbanffy | 2024-11-03T22:19:08 | Solving the Siberian Crater Mystery | null | https://nautil.us/the-mystery-of-the-siberian-craters-1051317/ | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,561 | gnabgib | 2024-11-03T22:22:30 | Training breaks do not impair long-term development in strength and muscle size | null | https://www.jyu.fi/en/news/breaks-in-resistance-training-do-not-impair-long-term-development-in-strength-and-muscle-size | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,571 | mooreds | 2024-11-03T22:23:19 | Wasp Flamethrower Drone Attachment | null | https://throwflame.com/products/flamethrower-drone-kit/ | 39 | 44 | [
42037698,
42037928,
42039127,
42037766,
42037859,
42037991,
42037840,
42037477,
42039256,
42039317,
42039251,
42039315,
42037593,
42037639,
42038198
] | null | null | null | null | null | null | null | null | null | train |
42,036,587 | OmarShehata | 2024-11-03T22:26:25 | Real-time text search for US politics video clips | null | https://www.whatpoliticssay.com/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,592 | kiyanwang | 2024-11-03T22:26:48 | Solving staffing challenges with concentric circles | null | https://theengineeringmanager.substack.com/p/solving-staffing-challenges-with | 1 | 0 | null | null | null | no_error | Solving staffing challenges with concentric circles | 2024-10-30T20:30:40+00:00 | James Stanier | As you begin to lead organizations that are of a reasonable size, such as in the hundreds of engineers, you will find that staffing is one of the most repetitive and challenging aspects of your job.Ensuring that you have enough people focused on the right things, with the right skills, and in the right places is a never-ending task. It is also by definition unsatisfiable: you will never have enough people to do everything you want (or need) to do, and you will never have the perfect mix of skills and experience either.Organizations of this size typically span a wide range of products, technologies, and geographies, further complicating the issue of having the right number of people working on the right things.You’ll have production code that needs to be maintained, new features that need to be built, and bugs and support issues that need to be addressed. It’s a balancing act.When inevitably a team’s project pivots, expands in scope, or is just plain harder than expected, you’ll be asked to provide them more people to help. However, this isn’t straightforward as everyone else is equally busy. If you find yourself in wartime it may be the case that you can’t rely on hiring your way out of the problem either.So, let’s imagine that one of your 30 teams is asking for more people. What do you do?Before we think about what to do, perhaps we should imagine ourselves in that team’s shoes. What are they expecting you to do when they ask for more people?If they have a new and important thing to do, they may assume that you will prioritize their work over other lower-priority work, thus allowing people to move from the less important thing to the more important thing. This assumes that you have a continual stack ranking of all of the work that needs to be done at any given time and that this team’s work is somewhere near the top of the stack.It may be the case that you have a stack ranking like this. And if you do, good on you. However, if you’ve ever tried to do a stack ranking of, say, hundreds of projects and teams that span multiple products and pieces of infrastructure, you’ll know that it soon becomes quite complex: how do you compare scaling infrastructure with a new feature that could drive revenue versus another new feature that could unlock some big strategic deals?These stack rankings also often rank ongoing projects and initiatives and do not always take into account the need to maintain and improve existing products and services, which is especially true in SaaS: nothing is ever really done, it is running in production and needs to have a base level of maintenance and improvement over time.Instead, many organizations operate, often implicitly, on a pool of investments approach: there are X products or services that exist in production, spread amongst Y teams, and your optimization is to ensure that those products or services are being maintained and improved in a way that is consistent with the overall strategy of the organization.This is a much more nuanced approach than a simple stack ranking, and it is often the case that the right thing to do is to not move people from one team to another, even if the other team’s work is more important, since it leads to an unacceptable level of entropy in the overall system.Stack ranking taken to the extreme can lead to a situation where the pool of investment approach breaks entirely: you could argue that whatever the top 3 projects are, they should get all of the staffing, and the rest should get nothing. This is clearly not a good strategy as everything else would need to be abandoned.Given that you are likely operating in a pool of investments model which is more nuanced than a simple stack ranking, is there a more nuanced way to think about staffing challenges?When you are faced with no obvious way to solve a staffing challenge, it can be helpful to think about the problem differently. One way to do this is to think about the situation in terms of concentric circles.What I mean by concentric circles is imagining that the team asking for more people is at the center of a series of circles:The innermost circle is the team itself which is asking for more people.The next circle out is the team’s immediate neighbors in the org chart. They will typically share a common manager.The next circle out is the team’s broader organization. This could be a product group, a business unit, or a division. This may be the org that you run.Outside of the circle is the entire rest of the department, outside of your organization and control.It looks a bit like this.The idea is that you should try to sequentially work your way out from the innermost circle to the outermost circle, looking for ways to solve the staffing challenges at each level. You do this will the manager of each circle, asking them to help you solve the problem.For example, this could look a little like this:Starting at the innermost circle, you work with the team to see if there is any work that can be stopped, delayed, or de-prioritized to free up capacity without needing to add more people in the first place. You may be surprised at how effective this can be.If the above does not work, then you work with the manager of the team and its immediate neighbours to see if there is any way that people could temporarily or permanently move between sibling teams to help out. One benefit of this approach is that the people moving are more likely to have context and have a shared mission or goal with the team they are moving to.If that does not work, then you work with your direct reports to see if there is any way that people could move between teams in your broader organization. This is effectively what you would likely have been asked in the first place, but by working your way out from the innermost circle, you have a better chance of finding a solution that is more nuanced and less disruptive first.If all else fails, then you work with your peers in the department to see if there is any way that people could move between organizations. However, this is the most disruptive and should be a last resort, and in large organizations, it is often the case that this does not work without further escalation.There are several benefits to this approach. Firstly, from experience, you often solve the staffing problem by the time you’ve gotten to the second bullet point. This makes it faster to solve and less disruptive.Secondly, and importantly, you are implicitly coaching your managers that you do not need to be the arbiter of all staffing challenges and that they should be working with their peers to solve these problems themselves with the trade-offs that they need to make. This is very healthy in the long run.Next time you have a staffing challenge, try thinking about it in terms of concentric circles. If you’re on the asking team, why not think of solving from the inside out first? | 2024-11-08T08:58:15 | en | train |
42,036,593 | doener | 2024-11-03T22:27:02 | I Spent $10k to Play Euro Truck Simulator 2 [video] | null | https://www.youtube.com/watch?v=cgfx2mLSI-A | 4 | 0 | [
42040684
] | null | null | null | null | null | null | null | null | null | train |
42,036,598 | nerdright | 2024-11-03T22:27:33 | The Rules for Rulers | null | https://www.youtube.com/watch?v=rStL7niR7gs | 2 | 0 | null | null | null | no_article | null | null | null | null | 2024-11-07T22:29:28 | null | train |
42,036,600 | nomilk | 2024-11-03T22:27:36 | AI Cracked the Protein Folding Code and Won a Nobel Prize [video] | null | https://www.youtube.com/watch?v=cx7l9ZGFZkw | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,616 | freecoins24 | 2024-11-03T22:29:51 | null | null | null | 1 | null | [
42036617
] | null | true | null | null | null | null | null | null | null | train |
42,036,625 | sdavidprince | 2024-11-03T22:31:40 | Grt | null | https://www.samanthaming.com/blog/how-i-got-my-first-developer-job-without-a-cs-degree/ | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,638 | belter | 2024-11-03T22:33:21 | Microsoft Debuts Mass Timber Data Centres | null | https://datacentremagazine.com/articles/microsoft-debuts-mass-timber-data-centres-in-us-push | 5 | 1 | [
42036745,
42040683
] | null | null | null | null | null | null | null | null | null | train |
42,036,647 | mooreds | 2024-11-03T22:34:07 | What the Nuclear Power Revival Means for the Price of Uranium [video] | null | https://www.youtube.com/watch?v=z22JzpWbrn8 | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,652 | transpute | 2024-11-03T22:35:16 | HardenedBSD Feature Comparison with OpenBSD, FreeBSD, NetBSD | null | https://hardenedbsd.org/content/easy-feature-comparison | 98 | 73 | [
42037958,
42037208,
42038864,
42039069,
42037109,
42039073,
42038231,
42039899,
42039578,
42037697,
42039257,
42036986,
42047681,
42039944
] | null | null | null | null | null | null | null | null | null | train |
42,036,665 | MilnerRoute | 2024-11-03T22:37:17 | null | null | null | 4 | null | [
42040678
] | null | true | null | null | null | null | null | null | null | train |
42,036,694 | auden_pierce | 2024-11-03T22:40:52 | Show HN: I launched a super cheap and simple to use OCR tool for macOS | 1. Click capture text
2. Select an area on screen with text
3. Paste the text anywhere<p>Are there other solutions out there? Yes, the best one that I've found is Text Sniper, it $8 so I decided to learn SwiftUI and release Text Capture for $0.99. This one uses MacOS builtin Vision API under the hood so it should also improve with new macOS releases. Would love to hear your feedback! | https://www.textcapture.app/ | 24 | 41 | [
42037495,
42037466,
42038717,
42037489,
42041382,
42037522,
42037897,
42037937,
42037523,
42037967,
42037262
] | null | null | no_error | TextCapture | null | null | Perfect for all macOS users. Capture non-selectable text and use anywhere.Supports macOS 14 Sonoma or newer,Intel and Apple Silicon👆Click "Capture Text" (⇧⌘2)🥳Paste text anywhere (⌘v)TextCapturePerfect for all mac usersQuick text capture Advanced OCR Multi-language support Customizable shortcuts Lifetime updates Pay once. Access forever.Hey, it's Auden, creator of Text Capture 👋Ever tried to quickly copy and paste some text, only to realize it's unselectable or embedded in a video or image? That happens to me all the time!While there are some solutions out there, they're often too complicated, packed with unnecessary features, or way more expensive than I expected.That's why I created Text Capture — a simple app with an intuitive UI and straightforward pricing, designed to do one thing well: help you copy and paste any text effortlessly.I'm building Text Capture and more in public. I'd love to hear your feedback!FAQFrequently Asked QuestionsNeed help with something? Here are some of the most common questions we get.Unlock Effortless Text CaptureOne-Time Payment, No Subscriptions!OCR tool for macOSCopyright © 2024 - All rights reserved | 2024-11-08T07:30:31 | en | train |
42,036,733 | rbanffy | 2024-11-03T22:47:19 | Why Facts Don't Change Our Minds | null | https://www.newyorker.com/magazine/2017/02/27/why-facts-dont-change-our-minds | 94 | 85 | [
42038457,
42038726,
42036823,
42038182,
42038276,
42038516,
42038737,
42044472,
42039091,
42038743,
42038484,
42038732,
42042212,
42038963,
42039233,
42038353,
42038754,
42039456,
42040157,
42038503,
42038596,
42045164,
42039077,
42038940,
42039532,
42038602,
42038826
] | null | null | no_error | Why Facts Don’t Change Our Minds | 2017-02-19T19:00:00.000-05:00 | Elizabeth Kolbert | Among the many, many issues our forebears didn’t worry about were the deterrent effects of capital punishment and the ideal attributes of a firefighter. Nor did they have to contend with fabricated studies, or fake news, or Twitter. It’s no wonder, then, that today reason often seems to fail us. As Mercier and Sperber write, “This is one of many cases in which the environment changed too quickly for natural selection to catch up.”Steven Sloman, a professor at Brown, and Philip Fernbach, a professor at the University of Colorado, are also cognitive scientists. They, too, believe sociability is the key to how the human mind functions or, perhaps more pertinently, malfunctions. They begin their book, “The Knowledge Illusion: Why We Never Think Alone” (Riverhead), with a look at toilets.Virtually everyone in the United States, and indeed throughout the developed world, is familiar with toilets. A typical flush toilet has a ceramic bowl filled with water. When the handle is depressed, or the button pushed, the water—and everything that’s been deposited in it—gets sucked into a pipe and from there into the sewage system. But how does this actually happen?In a study conducted at Yale, graduate students were asked to rate their understanding of everyday devices, including toilets, zippers, and cylinder locks. They were then asked to write detailed, step-by-step explanations of how the devices work, and to rate their understanding again. Apparently, the effort revealed to the students their own ignorance, because their self-assessments dropped. (Toilets, it turns out, are more complicated than they appear.)Sloman and Fernbach see this effect, which they call the “illusion of explanatory depth,” just about everywhere. People believe that they know way more than they actually do. What allows us to persist in this belief is other people. In the case of my toilet, someone else designed it so that I can operate it easily. This is something humans are very good at. We’ve been relying on one another’s expertise ever since we figured out how to hunt together, which was probably a key development in our evolutionary history. So well do we collaborate, Sloman and Fernbach argue, that we can hardly tell where our own understanding ends and others’ begins.“One implication of the naturalness with which we divide cognitive labor,” they write, is that there’s “no sharp boundary between one person’s ideas and knowledge” and “those of other members” of the group.This borderlessness, or, if you prefer, confusion, is also crucial to what we consider progress. As people invented new tools for new ways of living, they simultaneously created new realms of ignorance; if everyone had insisted on, say, mastering the principles of metalworking before picking up a knife, the Bronze Age wouldn’t have amounted to much. When it comes to new technologies, incomplete understanding is empowering.Where it gets us into trouble, according to Sloman and Fernbach, is in the political domain. It’s one thing for me to flush a toilet without knowing how it operates, and another for me to favor (or oppose) an immigration ban without knowing what I’m talking about. Sloman and Fernbach cite a survey conducted in 2014, not long after Russia annexed the Ukrainian territory of Crimea. Respondents were asked how they thought the U.S. should react, and also whether they could identify Ukraine on a map. The farther off base they were about the geography, the more likely they were to favor military intervention. (Respondents were so unsure of Ukraine’s location that the median guess was wrong by eighteen hundred miles, roughly the distance from Kiev to Madrid.)Surveys on many other issues have yielded similarly dismaying results. “As a rule, strong feelings about issues do not emerge from deep understanding,” Sloman and Fernbach write. And here our dependence on other minds reinforces the problem. If your position on, say, the Affordable Care Act is baseless and I rely on it, then my opinion is also baseless. When I talk to Tom and he decides he agrees with me, his opinion is also baseless, but now that the three of us concur we feel that much more smug about our views. If we all now dismiss as unconvincing any information that contradicts our opinion, you get, well, the Trump Administration.“This is how a community of knowledge can become dangerous,” Sloman and Fernbach observe. The two have performed their own version of the toilet experiment, substituting public policy for household gadgets. In a study conducted in 2012, they asked people for their stance on questions like: Should there be a single-payer health-care system? Or merit-based pay for teachers? Participants were asked to rate their positions depending on how strongly they agreed or disagreed with the proposals. Next, they were instructed to explain, in as much detail as they could, the impacts of implementing each one. Most people at this point ran into trouble. Asked once again to rate their views, they ratcheted down the intensity, so that they either agreed or disagreed less vehemently.Sloman and Fernbach see in this result a little candle for a dark world. If we—or our friends or the pundits on CNN—spent less time pontificating and more trying to work through the implications of policy proposals, we’d realize how clueless we are and moderate our views. This, they write, “may be the only form of thinking that will shatter the illusion of explanatory depth and change people’s attitudes.”One way to look at science is as a system that corrects for people’s natural inclinations. In a well-run laboratory, there’s no room for myside bias; the results have to be reproducible in other laboratories, by researchers who have no motive to confirm them. And this, it could be argued, is why the system has proved so successful. At any given moment, a field may be dominated by squabbles, but, in the end, the methodology prevails. Science moves forward, even as we remain stuck in place.In “Denying to the Grave: Why We Ignore the Facts That Will Save Us” (Oxford), Jack Gorman, a psychiatrist, and his daughter, Sara Gorman, a public-health specialist, probe the gap between what science tells us and what we tell ourselves. Their concern is with those persistent beliefs which are not just demonstrably false but also potentially deadly, like the conviction that vaccines are hazardous. Of course, what’s hazardous is not being vaccinated; that’s why vaccines were created in the first place. “Immunization is one of the triumphs of modern medicine,” the Gormans note. But no matter how many scientific studies conclude that vaccines are safe, and that there’s no link between immunizations and autism, anti-vaxxers remain unmoved. (They can now count on their side—sort of—Donald Trump, who has said that, although he and his wife had their son, Barron, vaccinated, they refused to do so on the timetable recommended by pediatricians.)The Gormans, too, argue that ways of thinking that now seem self-destructive must at some point have been adaptive. And they, too, dedicate many pages to confirmation bias, which, they claim, has a physiological component. They cite research suggesting that people experience genuine pleasure—a rush of dopamine—when processing information that supports their beliefs. “It feels good to ‘stick to our guns’ even if we are wrong,” they observe.The Gormans don’t just want to catalogue the ways we go wrong; they want to correct for them. There must be some way, they maintain, to convince people that vaccines are good for kids, and handguns are dangerous. (Another widespread but statistically insupportable belief they’d like to discredit is that owning a gun makes you safer.) But here they encounter the very problems they have enumerated. Providing people with accurate information doesn’t seem to help; they simply discount it. Appealing to their emotions may work better, but doing so is obviously antithetical to the goal of promoting sound science. “The challenge that remains,” they write toward the end of their book, “is to figure out how to address the tendencies that lead to false scientific belief.”“The Enigma of Reason,” “The Knowledge Illusion,” and “Denying to the Grave” were all written before the November election. And yet they anticipate Kellyanne Conway and the rise of “alternative facts.” These days, it can feel as if the entire country has been given over to a vast psychological experiment being run either by no one or by Steve Bannon. Rational agents would be able to think their way to a solution. But, on this matter, the literature is not reassuring. ♦ | 2024-11-08T05:13:23 | en | train |
42,036,742 | cande | 2024-11-03T22:48:49 | null | null | null | 1 | null | null | null | true | null | null | null | null | null | null | null | train |
42,036,783 | shchegrikovich | 2024-11-03T22:54:59 | null | null | null | 1 | null | null | null | true | null | null | null | null | null | null | null | train |
42,036,797 | MathCatHat | 2024-11-03T22:58:00 | null | null | null | 1 | null | [
42036798
] | null | true | null | null | null | null | null | null | null | train |
42,036,821 | mikerg87 | 2024-11-03T23:02:04 | What's Killing All the iMacs? [YouTube] | null | https://www.youtube.com/watch?v=yWOSkVL-0Ac | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,830 | Hormold | 2024-11-03T23:03:16 | Show HN: CMD+C – Instant Grammar Correction Across All Apps for macOS | Hey HN!<p>Here is my simple native macOS app for correcting grammar — CMD+C.<p>I'm a non-native English speaker working in English-speaking teams, and I care about how my Slack messages and other communications come across. Frustrated with switching between grammar tools, apps that don't support some input boxes, and endless copy-pasting, I built CMD+C — a simple macOS app that corrects grammar on the fly in any app, with just a triple-click.<p>Features:<p>1) Triple-click "⌘+C" to correct any selected text instantly, no matter where you're typing.<p>2) Use your own API key (OpenAI, Anthropic) or access premium corrections with our plan.<p>3) View correction history with explanations from GPT why it was corrected and export JSON/CSV if needed.<p>How it works:<p>1) Intercept triple "⌘+C" shortcut in macOS<p>2) Process text with LLM (OpenAI, Anthropic) with custom prompt<p>3) Replace selected text with the corrected version and save it to better understand why and how it was corrected<p>CMD+C was built in 7 days, is free to use, and I plan to share the source code later this month.<p>I've never built anything before, so I'd love your feedback - let me know what you think!
Hope someone finds it useful! | https://cmd-c.app | 4 | 2 | [
42040754
] | null | null | null | null | null | null | null | null | null | train |
42,036,852 | hackerbeat | 2024-11-03T23:09:43 | null | null | null | 1 | null | null | null | true | null | null | null | null | null | null | null | train |
42,036,858 | ohjeez | 2024-11-03T23:09:55 | Giant Rats in Tiny Vests Trained to Sniff Out Illegally Trafficked Wildlife | null | https://www.iflscience.com/giant-rats-in-tiny-vests-trained-to-sniff-out-illegally-trafficked-wildlife-76598 | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,875 | eugeniasergio3 | 2024-11-03T23:12:37 | null | null | null | 2 | null | null | null | true | null | null | null | null | null | null | null | train |
42,036,879 | mosbe | 2024-11-03T23:13:08 | Mobile-focused MitM tool with a built-in VPN setup and easy-to-use proxy UI? | Hey all,<p>I’m working on a MITM tool tailored for real-time mobile traffic analysis that might fill some gaps left by existing options like mitmproxy or Charles. Here’s the pitch:<p>VPN-Based Setup: The tool works via a VPN configuration that includes an automatic certificate installation process, so there’s no need to be on the same local network as the target device. This makes setup easy, even for mobile testing on the go.<p>MITM Proxy-Style UI: Users get access to a familiar proxy-style interface displaying all captured requests in real time, with filtering and sorting options.<p>I’m interested in feedback from those who regularly use tools like mitmproxy or Burp. What features or pain points could this address? Would the VPN setup be valuable in your work?<p>Thanks in advance for any insights! | null | 3 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,885 | rntn | 2024-11-03T23:14:08 | Ancient Paw Print on a Pottery Fragment Is Oldest Known Evidence of Cat Kneading | null | https://www.smithsonianmag.com/smart-news/this-ancient-paw-print-on-a-pottery-fragment-in-jerusalem-is-the-oldest-known-evidence-of-a-cat-kneading-180985360/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,892 | eugeniasergio3 | 2024-11-03T23:15:33 | null | null | null | 2 | null | null | null | true | null | null | null | null | null | null | null | train |
42,036,928 | kingdompetshop | 2024-11-03T23:19:56 | null | null | null | 1 | null | [
42036929
] | null | true | null | null | null | null | null | null | null | train |
42,036,934 | todsacerdoti | 2024-11-03T23:21:06 | Macros, Safety, and SOA | null | https://tim-harding.github.io/blog/soa-rs/ | 4 | 0 | null | null | null | no_error | Macros, Safety, and SOA | Tim Harding | null | null | About a year ago I wrote soa-rs, a structure-of-arrays (SOA) crate for Rust that makes extensive use of procedural macros and unsafe. In this post, I want to reflect on my experience with those tools. Much that I have to say mirrors Chad Austin's recent Unsafe Rust Is Harder Than C, which perfectly articulates the unsafe experience:The result of my pain is a safe, efficient API.Background SOA is a way of organizing linear data for efficient access on modern computers. Consider this type:ruststruct Foo(u8, u64);
let foos = vec![Foo(0, 1), Foo(2, 3)];Because of memory alignment requirements, each Foo takes 128 bits of space, leaving 56 bits to waste. Further, suppose you iterate over many elements but only access the u8 field. Since RAM serves data by the cache line, 15 of every 16 bytes transferred is thrown out, forcing the CPU to wait for memory.SOA addresses this by storing each struct field as a separate array. That way, elements are tightly packed. No space is wasted to padding, and during iteration, every cache line byte goes to use. Here's what it looks like using soa-rs:rustuse soa_rs::{Soa, Soars, soa};
#[derive(Soars)]
struct Foo {
bar: u8,
baz: u64,
}
fn main() {
let soa = soa![
Foo { bar: 1, baz: 2 },
Foo { bar: 3, baz: 4 },
];
for mut foo in &mut soa {
*foo.bar *= 2;
}
assert_eq!(foo.bar(), [2, 6]);
}Design Several SOA crates have existed since before soa-rs. These crates generate a unique container type for each SOA struct. Generated code is tedious to develop and maintain, and each derive produces duplicate code, slowing down compilation. Instead, soa-rs generates only essential, low-level routines, moving most of the implementation to a generic container type, Soa.The most popular SOA crate creates a Vec for each field, multiplying the overhead of allocation and capacity tracking by the number of fields. Soa minimizes overhead by using one allocation for the collection. soa-rs spends most of its unsafe in generated code that manages pointers into this allocation for each field.Comparison to Zig Zig is the poster child of this data structure. Here's the example from above in Zig:zigconst std = @import("std");
const assert = std.debug.assert;
const Foo = struct {
bar: u8,
baz: u32,
};
pub fn main() !void {
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
const alloc = gpa.allocator();
var soa = std.MultiArrayList(Foo){};
defer soa.deinit(alloc);
try soa.append(alloc, .{ .bar = 1, .baz = 2 });
try soa.append(alloc, .{ .bar = 3, .baz = 4 });
for (soa.items(.bar)) |*bar| {
bar.* *= 2;
}
assert(std.mem.eql(u8, soa.items(.bar), &[_]u8{ 2, 6 }));
}Unlike Rust, Zig doesn't need a macro to do this, instead using its compile-time reflection system. MultiArrayList works with all structs, not just specially marked ones, so you can even use it with types from other libraries. Not only that, MultiArrayList also supports enums, storing small enum variants in separate arrays from large ones. It does all this in just 481 lines, compared to 3498 in soa-rs. It's superior by just about any standard of comparison. I have at times looked jealously at the ergonomics of raw pointers by default and the insane leverage of comptime. Hopefully one day we get reflection.Macros Procedural macros are tedious to write. Even with the aid of rust-analyzer and cargo-expand, it's difficult to diagnose generated code that fails to compile. Crucially, while the compiler will report a missing comma or lifetime violation, it won't point out the offending code. We love Rust for its error messages being helpful, friendly, and specific. In contrast, macro errors are vague and frustrating, forcing you to wade through the generated code for syntactic and semantic mistakes.Worse still is code that compiles but runs incorrectly. Ordinarily you might reach for a debugger to step through the code, but macro code offers no such affordance. Unless you can step through assembly and somehow deduce the macro code it comes from, println! is your only option.Complex procedural macro authorship would benefit massively from better compiler diagnostics and macro source maps. A line of generated code represents easily an order of magnitude greater maintenance burden than as much regular code, but tooling could go a long way to bringing them in line.Safety Before writing soa-rs, I believed that unsafe is difficult largely for the same reasons as C code. malloc, free, manual lifetime management, and so on. That is false. Unsafe Rust is much harder, peppered as it is with myriad requirements and pitfalls. These requirements are scattered between std documentation, the Rustonomicon, and tribal knowledge.In a matter of hours from publishing soa-rs, Steffahn appeared in my GitHub issues with two soundness bugs, each requiring significant API redesign. (I've since learned this is a shared experience for unsafe authors.) Even with Miri checking over my work and combing through the code for any issues I knew to look for, I still had major blind spots that an experienced programmer could easily unearth. The biggest problem with unsafe is the unknown unknowns — the fearsome gremlin of undefined behavior dwells in a hundred dark corners you mightn't know to check.In a lesser language I'm always a little on edge, never quite assured that I've covered all my tracks. In Rust, the type system provides the structure I need to code with confidence. Unsafe Rust is quite the opposite experience. You have to be on your guard at every step. In exchange, you get to share a zero-cost interface that cannot be misused. It's difficult, but no other language rewards your efforts quite the same.Beware swap The original SOA design looked like this:rustpub struct Slice<T: Soars> {
len: usize,
raw: T::Raw,
}
pub struct Soa<T: Soars> {
cap: usize,
slice: Slice<T>,
}
impl<T> Deref for Soa<T: Soars> {
type Target = Slice<T>;
fn deref(&self) -> &Self::Target {
&self.slice
}
}In this setup, most of the implementation work goes into Slice. Soa adds allocating methods like push and pop, but also gets all the methods from Slice for free via Deref and DerefMut implementations. This is the same way that Vec adopts slice methods. However, this runs into an issue:rustlet a = soa![Tuple(0)];
let b = soa![];
std::mem::swap(a.as_mut_slice(), b.as_mut_slice());
a.push(Tuple(0)); // segfault!By exposing a reference to the struct field, it's now possible to exchange the contents of two containers without updating the capacity to match. In this example, a thinks it has capacity to push an element, but contains a slice with no allocated capacity, causing the segfault. Vec doesn't have this issue because it dereferences to the unsized type [T], which can't be passed to mem::swap. We can make Slice unsized like so:rustpub struct Soa<T: Soars> {
cap: usize,
len: usize,
slice: Slice<T, ()>,
}
pub struct Slice<T: Soars, D: ?Sized = [()]> {
raw: T::Raw,
dst: D,
}The length field has moved to Soa, while Slice sports a new generic, D. When D uses the default generic parameter, [()], the struct becomes unsized. That way, when we hand users an &mut Slice<T>, they won't be able to mem::swap it. It also makes the struct dynamically sized, meaning that references to it have the same metadata as [()] itself. That allows us to store the slice length as part of the reference metadata. This isn't really necessary, but it's kind of neat that it works.Since dynamically sized types can't be stored in a sized type, we can also set D to () when storing it in the Soa. This is also handy for SliceRef, an owned type that acts like &Slice.rustpub struct SliceRef<'a, T: 'a + Soars> {
len: usize,
slice: Slice<T, ()>,
marker: PhantomData<&'a T>,
}SliceRef gives us the semantics of &Slice in a type with owned fields by storing a phantom reference, which tells the type system that we're borrowing data without our actually doing so. Whereas &Slice is necessary for implementing Deref, SliceRef is necessary to support slicing (as in &foo[1..5]). Usually you can't return a reference unless it's tied to something that outlives the function, which for Soa means referencing a struct field. Native slices are special; you can create one with slice::from_raw_parts and immediately return it from a function. Whereas &Slice points to slice information that has to live somewhere, &[T] is itself the slice information. SliceRef works similarly.Beware inner mutability Suppose you have this struct:ruststruct Struct(u8, u8);Since SOA stores the fields separately, a reference to a slice element looks like this:ruststruct StructRef<'a>(&'a u8, &'a u8);If Struct implements a trait, we'd like for StructRef to also implement the trait. To solve this issue I concocted with_ref, which takes a function and calls it with a Struct reference. The macro implements this by bitwise copying each field from StructRef to recreate the Struct on the stack, then calling the provided function with a reference to that Struct.rustpub trait WithRef {
type T;
fn with_ref<F, R>(&self, f: F) -> R
where
F: FnOnce(&Self::T) -> R;
}
impl WithRef for StructRef {
type T = Struct;
fn with_ref<F, R>(&self, f: F) -> R
where
F: FnOnce(&Self::T) -> R
{
use std::ptr::{read, from_ref};
let t = Struct(
unsafe { read(from_ref(self.0)) },
unsafe { read(from_ref(self.1)) },
);
f(&t);
}
}This way, you could make a SOA slice hashable using T's implementation of Hash, for example.rustimpl<T: Soars + Hash> Hash for Slice<T> {
fn hash<H: Hasher>(&self, state: &mut H) {
self.len().hash(state);
for el in self.iter() {
el.with_ref(|el| el.hash(state))
}
}
}This all seemed fine to me, and Miri had no complaints either. Since WithRef only calls f with an non-mut reference to the stack, you couldn't mutate anything, so there's no worry you'll affect the Soa contents. Right?Right?Well, I forgot to consider inner mutability. Here's how to expose the issue:rust#[derive(Soars)]
struct Foo(RefCell<String>);
let soa = soa![Foo(RefCell::new(String::default()))];
// Takes ownership of the Foo that with_ref created on the stack,
// but soa also still owns that memory.
let r = soa.idx(0).with_ref(|x| mem::take(x.0.borrow_mut()));
// Double free when r and soa are dropped.Even if it's normally safe to think of a shared reference as an immutable reference, they aren't always the same. This is the kind of thing that makes unsafe so hard to get right. You have to consider how your code interacts with all of Rust's myriad constructs, and it's easy to overlook some particular case where an errant bit of safe code comes along to ruin your day.Sadly, this kills the ability to implement a bunch of traits for SOA slices without some additional effort by the user, since we can't leverage the existing implementations on T for equality, ordering, equality, debug printing, or cloning. To help the situation, you can use #[soa_derive(Clone, Debug, ...)] to add derive implementations for SOA types, but it's not quite the same. If your implementations are more complex than simple derives, you'll have you maintain a copy of each for Soars::Ref and Soars::RefMut. I regret having to sacrifice API design to satisfy something of a corner case usage.Paper cuts Const is limited Having finished analogs for Vec, &[T], and &mut [T], I really wanted to round out the set with [T; N] and make compile-time SOA arrays that don't require allocation. This was hard enough that I gave up a few times, but being preternaturally stubborn, I eventually got this working:rust#[derive(Soars)]
#[soa_array]
struct Foo(u64, u8);
const FOOS: FooArray<2> = FooArray::from_array([
Foo(1, 2),
Foo(3, 4),
]);
assert_eq!(FOOS.0, [1, 3]);
assert_eq!(FOOS.1, [2, 4]);However niche the use case and however baroque the code to make this work, it's neat that this kind of thing is even possible. For the adventurous, this is roughly what the code looks like:rustconst fn from_array<T, const N: usize>(array: [T; N]) -> Self {
// We're taking ownership of the array contents,
// but Rust can't tell because it's pointer stuff.
let array = ManuallyDrop::new(array);
// Get a reference to the array.
let array = unsafe {
&*ptr::from_ref(&array).cast::<[T; N]>()
};
Self {
foo: {
let mut field = [const { MaybeUninit::uninit() }; N];
let mut i = 0;
while i < N {
let src = ptr::from_ref(&array[i].bar);
let read = unsafe { src.read() };
field[i] = MaybeUninit::new(read);
i += 1;
}
unsafe { transmute_copy(&field) }
},
// snip
}
}Being able to call trait methods in const contexts would be really useful. I can understand why this is a difficult problem, but it does hamper ergonomics considerably. For example, you can't use indexing or for loops because they rely on the Index and Iterator traits to work. I had to use some particularly weird casts because Deref isn't available.Unstable Occasionally, there are features and optimizations available to std implementers that aren't for library authors. For example, I would like to implement try_fold for my iterator type, but from what I can tell, this simply isn't possible. One of the function generics is R: Try<Output = B>, and since Try is unstable, you can't name the type when you go to write the function. It frustrating sometimes to see that a type is right there and in use but out of reach. All the NonNull stabilizations in 1.80 were exciting to see, having missed them during development. I delight in finding refactor opportunities when new functions are stabilized. Here's hoping for [MaybeUninit<T>; N]::transpose to replace transmute_copy in my from_array function.Index trait It's a bit unfortunate that certain traits like Index return &Self::Output instead of just Self::Output. I can't implement this type for Slice because I need to return SliceRef instead of a reference. I assume this constraint is because we didn't have GATs when these traits were being developed. Today we could writerusttrait Index {
type Output<'a>: ?Sized where Self: 'a;
// instead of
type Output: ?Sized;
}
impl<T> Index for Vec<T> {
type Output<'a> = &'a [T] where Self: 'a;
// instead of
type Output = [T];
}Because of this, users have to write soa.idx(i) instead of soa[i]. Not the end of the world, but more flexibility would be nice in a few places.Special cases Tuple structs, unit structs, and named field structs each have slightly different syntax that require special handling in macro code. For example, here's how you create a struct definition.rustmatch kind {
FieldKind::Named => quote! {
#ident { #(#field: #ty),* }
},
FieldKind::Unnamed => quote! {
#ident ( #(#ty),* );
},
FieldKind::None => quote! {
#ident;
}
}This is inconvenient given how many places these differences need to be accounted for. However, tuple structs have this nicety:ruststruct Tuple(u8, u8);
let tuple = Tuple { 0: 42, 1: 7 };You can treat tuple structs like named field structs for the purpose of initialization, so you don't need to handle them differently. I wish this feature were available in more areas.Crate setup Generated code has no knowledge of its context. It doesn't know what crate it's in, what symbols are imported, or whether you use std as cursed;. Therefore, you typically refer to symbols by their absolute path, such as ::std::vec::Vec. There is just one wrinkle: you cannot refer to the current crate this way. That is, you can't say ::my_crate::symbol from within my_crate. In macros by example you can use $crate, in procedural macros you cannot. Because of that, you are unable to invoke your macro in my_crate if the macro itself uses ::my_crate::symbol. That means you need a separate crate just for tests, on top of the ones for your macro and your library. This isn't the biggest deal, but it's one of those annoying administrative things that's foisted upon anyone learning proc macros for the first time.Tricks Testing compile failures Sometimes you want to test that a piece of code doesn't compile. I do this to ensure that certain types aren't Send or Sync, for example. The only way to do that is by writing a doctest with the compile_fail annotation:rust/// ```compile_fail
/// let number: u32 = "string";
/// ```
mod compile_fail_tests {}This tests that compilation failed, but not why it failed. I've made the mistake of writing one of these to test one thing, but compilation actually failed because I forgot a semicolon. To make sure you're testing the right thing, compile the failing code and make note of the error code:sherror[E0308]: mismatched typesThen, modify the doctest to specify the error code you expect.rust/// ```compile_fail,E0308Testing readme code If you have a readme with Rust code that you want to ensure compiles, you can do this:rust#[doc = include_str!("../README.md")]
mod readme_tests {}This is equivalent to including the readme as a /// documentation comment, so Rust will include it with the rest of your doctests.Conclusion However much I have to critique, unsafe Rust is uniquely rewarding. Nowhere else can I wrap a bundle of hairy, low-level, error-prone code behind a zero-cost interface that's impossible to misuse. Navigating the difficulties of unsafe makes me appreciate the safe subset of Rust all the more. Safe Rust is more enjoyable and productive for me than any other language, and I hope there's a future where I can say the same for its unsafe counterpart. Happy programming 🦀 | 2024-11-08T05:57:39 | en | train |
42,036,935 | tehlike | 2024-11-03T23:21:09 | Beer can math – recycling vs. reducing consumption | null | https://www.ucolick.org/~de/Snarf/Can.Math.html | 3 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,937 | LopRabbit | 2024-11-03T23:21:33 | A $1M teacher scheme left uncertified teachers in Texas | null | https://www.cnn.com/2024/11/03/us/houston-teacher-certification-scheme/index.html | 13 | 0 | [
42037654,
42039350
] | null | null | null | null | null | null | null | null | null | train |
42,036,942 | jonbaer | 2024-11-03T23:22:50 | Why AI Can't Exist Without Taiwan [video] | null | https://www.youtube.com/watch?v=bf1W-_x6Rvo | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,946 | Brahman_exe | 2024-11-03T23:23:04 | Ask HN: Why Doesn't ChatGPT Have the Memory Feature Enabled for O1 Models? | Anyone know why ChatGPT’s memory feature isn’t active in the O1-preview and mini versions? I’ve been tinkering with them, but they seem to forget earlier parts of the conversation. Is this intentional, a bug, or something else? If anyone’s got the lowdown, spill the beans! | null | 3 | 0 | [
42037493
] | null | null | null | null | null | null | null | null | null | train |
42,036,952 | jill64 | 2024-11-03T23:24:13 | null | null | null | 3 | null | [
42040668
] | null | true | null | null | null | null | null | null | null | train |
42,036,953 | ohjeez | 2024-11-03T23:24:21 | Communal Luxury: The Public Bathhouse | null | https://solar.lowtechmagazine.com/2024/09/communal-luxury-the-public-bathhouse/ | 4 | 0 | null | null | null | missing_parsing | Communal Luxury: The Public Bathhouse | 2024-09-17T00:00:00+00:00 | Kris De Decker |
Image: Bathhouse built on top of a hot pool, Taiwan. Photo from early 20th century, public domain.
View original image
View dithered image
No Running Water at Home
For people in industrial societies, few activities demand more privacy than washing and grooming the body. We usually do it alone, in our private bathrooms, with locked doors. Seen in a historical context, that is unusual. Bathing in the presence of others has been the rule rather than the exception. As late as the first half of the twentieth century, many households, even in the most advanced industrial societies, did not have running water at home, let alone a private bathroom. 1
A bathroom requires a domestic water supply, but also a sewer drain, and an energy source to heat the water. Of course, it’s possible to have a hot bath at home without these infrastructures. Ever since Antiquity, the rich have built private baths in their houses. Most often, they could do that because less well-off people - either servants or slaves - filled and emptied their bathtubs with bucketloads of water and collected firewood to heat them.
However, for most people, it was more practical to take their bodies to the water rather than the other way around. For some, that meant bathing in rivers, lakes, and springs. For others, especially in urban environments, it meant visiting the public bathhouse.
Image: Bathhouse in Aachen Germany, by Jan Luyken, 1682.
View original image
View dithered image
Is Bathing Unsustainable?
Modern bathing practices are a textbook example of an unsustainable lifestyle based on fossil fuels. Hot water production is the second largest energy use in many homes (after space heating and/or cooling), and much of it is used for bathing or showering. 2 The modern bathroom also uses a lot of water and adds extra energy use through space heating and waste-water treatment. Building and renovating bathrooms requires resources, too.
Sustainability advocates follow two strategies to address these problems. The first strategy concentrates on technological solutions, such as low-flow showerheads, water boilers heated by solar collectors, waste-water heat recovery systems, and greywater recycling. The second strategy counts on behavioral or social changes by questioning modern standards of cleanliness and comfort: bathing or showering shorter and less frequently, taking cold showers, or doing a cat wash at the sink. 23
These strategies are unlikely to bring much results. Many technological fixes are difficult or impossible to install in existing buildings, especially in cities. For example, as the number of floors increases, an apartment building quickly runs out of roof space to install solar collectors for all residents. On the other hand, promoting discomfort as a sacrifice for sustainability is unlikely to engage broader environmental practices. 34
Communal bathing makes it easier to disconnect bathing practices from fossil fuels.
Communal bathing could be a third approach, but it’s rarely mentioned. That’s remarkable because, in terms of resource efficiency, it’s hard to beat. Building and operating a bathhouse for 1,000 people requires much less energy than building and operating 1,000 individual bathrooms. A public bathhouse is also more efficient concerning materials, money, and space. 5
Just as importantly, public bathing makes applying the sustainable technologies mentioned above more feasible. That further reduces energy consumption and makes it possible to disconnect bathing practices from fossil fuels. Finally, a public bathhouse can achieve significantly improved sustainability without promoting discomfort. On the contrary, pooling resources to build something for a community rather than for every household separately allows for a high level of sustainable extravagance. That may be an easier sell than cold showers.
Image: Public bathhouse in Dunkirk, France, opened in 1897.
View original image
View dithered image
Bathing in Rivers, Lakes, and Hot Springs
Nature has provided humans with bathing facilities through streams, rivers, pools, lakes, waterfalls, and rain showers. Humanity spent much time in tropical Africa, where bathing did not require artificially heated water for comfort. When we moved into colder climates, Nature presented us with another solution: hot springs. Many tens of thousands of thermal springs exist around the planet — only a few present-day countries lack them entirely. 67
Bathing in hot springs was common in ancient civilizations all over the world. However, it’s a practice that goes back even further in time. Archeological evidence abundantly shows that many prehistoric settlements established themselves near hot springs. 68 It’s impossible to prove rock solid that people used those waters for bathing, but why wouldn’t they, especially in cold regions? 9
Enjoying a hot bath is a practice that predates recorded history.
Today’s bathing culture relies on fossil fuels, but if we consider the historical context, enjoying a hot bath is not unsustainable. In the case of hot springs, the entire infrastructure and operation — water supply, drainage, and heat source — are already in place.
Our ancestors also invented the steam or sweat bath to take advantage of cold water in all seasons and climates. Rather than heating water, it heats people so they can bathe comfortably in cold water. The earliest steam huts, from prehistoric times, were little more than small log cabins or tent-like structures covered with woolen blankets or hides. 10111213
Painting: Bathing Place, oil on canvas, Paul Gauguin, 1886.
View original image
View dithered image
The Birth of the Bathhouse
Artificial bathing facilities made from brick or stone appeared around 4,000 years ago. 14 They could be an open-air pool, a bathhouse, or a private bathroom. Many bathhouses and bathing pools were built on top of natural hot springs, modifying the natural environment to make it more convenient, safe, and attractive.68 People also began to divert water into urban bathing facilities using canals, pipes, and aqueducts. They started building baths that used artificially heated water as well.
The Ancient Romans are most famously associated with the public bathhouse, although they took much inspiration from the Ancient Greeks. Greek bathhouses comprised rooms with individual hip baths against the walls. Sitting up straight, the bathers threw hot water over themselves or had this done by a servant. In contrast, Roman bathers shared the water in large bathtubs or pools. Both used steam baths as well. 15161718
At the height of the Empire, there were around 1,000 public baths in the city of Rome alone for a population of about 1 million people - one bathhouse per 1,000 people. 819 The most prominent bathhouses were the “thermae,” which could hold up to a few thousand people bathing at the same time. These facilities, which only appeared in the largest cities, were richly decorated with mosaics, marble floors and pools, granite columns, and statues. However, most Ancient Roman bathhouses were smaller neighborhood baths called “balnea.” 15
Image: Cross-section of the Baths of Diocletian by French architect Edmond Paulin, 1880. This bath complex was the largest of Ancient Rome, with a capacity of over 3,000 people.
View original image
View dithered image
The Preindustrial Bathhouse
The public bathhouse’s history continues after the Roman Empire’s demise. In the East, the Roman bathhouse evolved into the hammam, which ditched the pools and concentrated more on sweating as a cleaning method.2021 After a sweat bath, people threw water over themselves. Reminiscent of the small Roman baths known as balnea, hammams spread in large numbers in all cities of the Islamic world as they facilitated bodily cleanliness and the accomplishment of body ablutions before praying. 22
In Western Europe, many Roman baths fell into disrepair. However, the public bathhouse returned in full swing during the late Middle Ages, when a new period of urbanization set in. 232425 In the 13th, 14th, and 15th centuries, a lot of European cities had a public bathhouse per 2,000 to 5,000 citizens.26 Many were steam baths inspired by the hammam. A second type of bathhouse offered wooden bathtubs to seat a small group of people. The medieval bathhouse was known as a “stew,” which refers to the oven that either heated water for the bathtubs or filled the room with steam. 2325
Image: A former medieval bathhouse, built in 1562, in Münden, Germany. Photo by Axel Hindemith (CC BY-SA 4.0).
View original image
View dithered image
Image: The women’s bathhouse, by Albrecht Dürer, 1496.
View original image
View dithered image
Painting: Rudas Baths, Ludwig Rohbock, 1850. The Rudas Baths in Budapest were built in 1550 and are still in operation.
View original image
View dithered image
Northern Europe and Russia - never conquered by Roman or Islamic Empires - stuck to sweat and hot air baths. For example, public “banyas” existed in towns throughout Muscovy during the Middle Ages. 12 Asia also developed independent bathing cultures. For instance, in late medieval Japan, people shared private hot baths among families, neighbors, and friends for economic reasons. For these “cooperative baths” of mostly four to ten individuals, every bather brought a portion of firewood to heat the water. That practice evolved into larger public baths - “sento” - which experienced rapid growth from the fifteenth century onwards.2728
Image: Women taking a vapour bath. Wood engraving by Olaf Sörling.
View original image
View dithered image
Image: Men in a Japanese bathhouse, early twentieth century. Image in the public domain.
View original image
View dithered image
Bathing for Pleasure
Nowadays, sustainability advocates who promote shorter or less frequent showers implicitly regard bathing as a strictly utilitarian practice. However, for most of history, bathing was never just about hygiene. Apart from getting clean, people also visited public baths to relax, have fun, and socialize. Rather than a quick affair, the bathing process — no matter its form — often went on for hours. 1528
The Ancient Greeks sat together in individual bathtubs, having conversations, for which the space’s acoustics were optimally suited. 29 In Ancient Rome, public baths were places where people went almost daily to be seen, mingle, relax, gossip, dine, or play sports and study. Bathers accessed beauty treatments such as massages, shaving, hairdressing, and depilating. They celebrated parties and anniversaries and honored foreign guests. 1517192530
Rather than a quick affair, the bathing process — no matter its form — often went on for hours.
The medieval European bathhouse continued these traditions with less splendor but not necessarily with less revelry. In particular, medieval stews with wooden bathtubs were often a place of amusement that also furnished food, drink, music, and various types of bodily care. 23 In Japan, during the 16th century, public baths became places to gather and socialize, with large groups of people eating, drinking, and singing. 2728 River bathing, which continued around cities and in rural areas until the 20th century, was a kind of play in which swimming was a potential element. 31
At the same time, bathing was considered essential to prevent and cure diseases, following the Hippocratic ideas that people could maintain or restore the balance of bodily fluids by exposing the body to cold, hot, moist, or dry circumstances. The layout of preindustrial baths reflected these ideas, featuring pools and spaces of different temperatures. 1521
Image: Miniature drawing in “De Sphaera Mundi”, written by Johannes de Sacrobosco, circa 1230.
View original image
View dithered image
Playing chess at the Széchenyi Baths in Budapest, Hungary, 1970s. Photo by Kereki Sándor. Found at Fortepan.
View original image
View dithered image
While these elements of pleasure, social interaction, and health continue today in mineral spas, there is a crucial difference with earlier bathing practices. The present-day spa is far too expensive to substitute for a private bathroom. In contrast, the historical public bathhouse was an egalitarian institution.
Roman public baths had no or low entrance fees and were open to everyone. There were no areas reserved for higher-ranking patrons. Combined with the splendid architecture and opulent decoration of the baths, this ensured that even the most humble servant would have a taste of luxury. 151719 These customs continued into the European Middle Ages and were shared by bathing cultures across the world. 23 For example, in Japan, the bathhouse aided in “slowly deconstructing the existing social hierarchy and created a new cultural flow between the elite and the commoners.” 2832
The only separation happened between men and women, and it was far from universal across space and time. They would either go to different bathhouses, occupy different sections, or share the same spaces at different times of the day or the week. 1215171923
Image: A sento in Japan. Photo by Stuart Gibson.
View original image
View dithered image
The Fuel Use of Roman Bathhouses
How sustainable was that communal luxury? Most research about the energy use of bathhouses concerns Ancient Roman baths. Historians have sometimes faulted the large bathhouses from the Empire for their wastefulness, arguing that their widespread use caused deforestation. 333435 However, in recent years, archeological research, thermal analysis, and heat transfer studies have made it increasingly clear that Ancient Roman bathhouses, in spite of their opulence, were remarkably energy-efficient buildings. 3633
The first reason was the hypocaust system. It consisted of one or more underground furnaces that distributed hot air under the floor and into the hollow walls (some baths had heated ceilings, too). Because of the large radiant surfaces, the spaces in the building could be heated at a lower temperature, saving energy. Although the water for the pools was reheated periodically in an insulated boiler close to the furnace, the heat in the floors and the walls helped to keep it warm for an extended period. 3633
A study of the Stabian Baths, one of the oldest surviving thermae, shows a fuel consumption of between 5 and 8 kg of firewood per hour, depending on the season. 3637 That corresponds to a wood supply of slightly more than 60 ash trees per year, which was unlikely to cause deforestation. 36 Firewood consumption was probably even lower because Roman baths routinely supplemented wood with other locally available fuels, often waste products: reeds, harvest by-products (olive pits, orchard trimmings, chaff), and animal wastes (dung and bones). 33
Many Roman baths were heated almost exclusively by solar energy on sunny days.
Following the same methodology, a study of a later bathing complex - the Forum Baths in Ostia - shows that the Romans continued improving their bathhouses’ energy efficiency. 3839 The Forum Baths were three times larger than the Stabian Baths - 923m2 versus 310m2 of heated spaces - but their calculated annual wood consumption is not even twice as high: roughly 100 trees per year. 3836 The newer bathhouse had thicker walls (two meters instead of one meter), as well as much larger glazed windows, which increased the share of solar radiation. 40 Earlier research has shown that the Forum baths were heated almost exclusively by solar energy on sunny days. 41
The studies above assume that the Romans heated their baths for 24 hours daily and only shut them down for maintenance. Roman bathhouses likely continued to be heated through the night, as it was more practical and energy-efficient. Many baths were open daily, and it could take a whole day to heat them from a cold state. In later centuries, medieval stews and hammams often used the heat or the ashes of the furnace to bake bread and other foods at night. 42 Hammams and medieval stews were less energy-efficient than Roman baths. Hammams had heated floors but no heated walls and few windows, while medieval stews often had none of these.
Image: The large windows of the Forum Baths. Image: Jan Theo Bakker.
View original image
View dithered image
Image: The hypocaust of the Great Baths complex, Ancient Dion. Imgae by Carole Raddato (CC BY-SA 2.0).
View original image
View dithered image
Image: Historical Reconstruction of the Roman Baths in Weißenburg, Germany, using data from laser scan technology. Credit: CyArk. CC BY-SA 3.0
View original image
View dithered image
Roman Bathhouse Versus Private Shower
How does the energy use of the Roman bathhouse compare to that of the modern shower? Academic research does not provide an answer, but a quick calculation shows that the Roman bathing experience, which lasted for hours, was more energy-efficient than the present-day private shower, which lasts, on average, 9 minutes. The daily energy use of the Forum baths corresponds to the daily energy use of 557 showers. 43 While we don’t know how many people visited the Forum Baths daily, they likely surpassed that number: the baths could host up to 500 bathers simultaneously. 44
The Roman bathing experience, which lasted for hours, was more energy-efficient than the present-day private shower, which lasts, on average, 9 minutes.
Furthermore, in the calculation above, the energy use for the shower only concerns water heating, while the fuel use for the public baths also - and mainly - includes space heating. 36 For example, assuming that the water in the pools of the Stabian baths was changed only once per day, heating the water accounted for less than 10% of the total energy use, corresponding to the energy use of only 52 showers. The low energy use for water heating is partly explained by the excellent thermal insulation of the heated floors and walls, meaning that space and water heating cannot be separated. However, it is also because the Romans shared the water in pools, while every shower requires freshly heated water.
The Roman bathhouse also compares favorably to the typical backyard sauna, for which the fuel consumption hovers between 5 and 15kg of firewood per session. 45 Only sixteen such sauna sessions require as much fuel as the Stabian baths used daily. The sauna has no heated floor and walls. Furthermore, historically, it was often built partly underground to save fuel, but nowadays, it’s usually a badly insulated building standing in a cold climate.
Image: Bathing sandals for women, Saudi Arabia. Heated floors of hammams were too hot to walk on barefoot. Source: Wereldmuseum (CC BY-SA 4.0).
View original image
View dithered image
The Public Baths of the Industrial Revolution
Bathing practices have changed quite a lot since Roman and late medieval times, particularly in most of the Western world. Few of us will have the time or even the need to linger in a bathhouse for several hours daily, and some of us may feel uncomfortable bathing in public. 30 However, a bathhouse can also take a form more in line with modern bathing habits. The public bathhouse of the Industrial Revolution demonstrates this.
In the nineteenth and early twentieth centuries, cities received large numbers of immigrants who came to work in factories. Most of these people were housed in overcrowded tenement buildings without running water, leading to unsanitary conditions. 46 Recurring epidemics and new medical insights led to a “gospel of cleanliness” that resulted in a new wave of public bathhouses across the Western world. Many of these baths only disappeared between the 1950s and 1980s.
The public hygiene movement began in England and peaked there in the 1840s. By 1896, more than 200 municipalities in Britain were maintaining public baths. The English bathhouse emulated the splendor of Roman baths in its architecture and decoration: it was “large, handsome, and costly.” 46 However, it did not copy the Ancient bathing customs. It now reserved different sections of the bathhouse for different social classes. Furthermore, while the pools still provided social interaction, the bathtubs were now placed in individual compartments. Finally, the modern bathhouse instituted maximum time limits for using the pool and the bathtubs. 464748
Image: Nechelles public baths in Birmingham, England, 1910. Image by Oosoom (CC BY-SA 3.0).
View original image
View dithered image
Image: The restored interior of the Amalienbad in Vienna, Austria, built in 1926. It was one of the largest bathhouses in Europe at the time, holding up to 1,300 bathers simultaneously. The original roof could slide open in good weather. Image by Schwimmschule Steiner (CC BY-SA 4.0).
View original image
View dithered image
The Shower Bathhouse
Germany, the first to follow the British on the continent, also built monumental bathhouses. 49 However, in the 1880s, Berlin physician Oscar Lasser argued that the large baths were too costly to build in the necessary numbers. He proposed the introduction of smaller bathhouses with nothing but showers in individual compartments. Until then, the shower was only attached to a bathtub or used in barracks and prisons, where soldiers and inmates were showered with cold water. 484625
The shower bathhouse became the dominant public bath type in most of Western Europe and also in North America, where the sanitary reform movement took off in the 1890s. 5051 It cleared away the last vestiges of the Ancient bathing culture by ditching the pools and switching to a more practical architecture. For better or worse, the public bathhouse from the Industrial Revolution was the “antithesis of the preindustrial bathhouse.” 47 Although bathers still made use of communal infrastructure, there was no more space for pleasure, social interaction, public nakedness, and social mixing.
For better or worse, the public bathhouse from the Industrial Revolution was the antithesis of the preindustrial bathhouse.
As the higher social classes gradually gained access to their private water supply and bathrooms, the public bath became increasingly associated with poverty. Although shower bathhouses did not have separate sections for different social classes, they were mainly built in low-income neighborhoods, aimed at the poor only. Bathers were led to their shower cubicle by an attendant, who opened the tap, decided on the water temperature, and started a timer. People had at most 20 minutes to undress, shower, and dress again.4647 “The poor had to be clean but not enjoy it too much.” 46
Image: The last bath attendant of a bathhouse in Haarlem, the Netherlands, in 1984. Image in the public domain.
View original image
View dithered image
Bath and shower rooms equipped with timers in Amsterdam bathhouses, 1985. Source: Stadsarchief Amsterdam.
View original image
View dithered image
Image: Shower cubicles in a municipal bathhouse in Amsterdam, the Netherlands. Stadsarchief Amsterdam.
View original image
View dithered image
Image: Boiler room of a municipal bathhouse in Amsterdam, the Netherlands, 1985. Stadsarchief Amsterdam.
View original image
View dithered image
Bring Back the Public Bathhouse?
In Europe and North America, the public bathhouse disappeared once everyone got their private bathroom - although we still bathe together in sports centers and continue using communal bathrooms in hostels or campings. The public bathhouse survives elsewhere but is in decline almost everywhere. For example, Cairo had only eight hammams in 2000, compared to more than seventy at the beginning of the 19th century.5253 In 1968, greater Tokyo boasted 2,687 public bathhouses. In 2022, only 462 were left. 5455
Historically, the bathhouse was born out of the need for efficiency: bathing was too resource-intensive to organize individually. That is no longer the case thanks to the advance of central infrastructures - fossil fuels, electricity, water supply, sewers. However, in the context of the present environmental crisis, the resource efficiency of the public bathhouse has become relevant once again. It’s a solution that could reduce energy use relatively quickly without the need for new technologies or sacrificing comfort. Resilience is another argument for the bathhouse. 56
Image: Municipal bathhouse at Javaplein in Amsterdam, the Netherlands. Image: Stadsarchief Amsterdam.
View original image
View dithered image
Image: A former bathhouse in Flensburg, Germany. Image: VollwertBIT (CC BY-SA 2.5).
View original image
View dithered image
What Type of Public Bathhouse Do We Want?
The metamorphosis of the public bath in the 19th and 20th centuries, which also affected public baths outside the Western world, presents a challenge to anyone wanting to revive public bathing for sustainability. What type of bathhouse do we want? Of course, the Roman bath and the shower bathhouse are both extremes, and many intermediate forms are imaginable. Nevertheless, any designer of a future bathhouse will have to make decisions that are likely to be controversial.
For example, one could argue that the shower bathhouse not only fits modern bathing practices but also maximizes resource efficiency. That is especially true when the government, rather than the bather, controls shower duration and water temperature. In that way, the public bathhouse could become a technology to enforce frugality upon the whole population. However, to put it mildly, such an approach is unlikely to generate enthusiasm for reviving public bathhouses. Neither does it do much to improve social interaction. 57
Any designer of a future bathhouse will have to make decisions that are likely to be controversial.
Advocating for the return of the preindustrial public bathhouse, which centers around social interaction and communal luxury, may be more successful in luring people away from their private bathrooms, but it also runs into obstacles. The public bathhouse has faced resistance for 2,000 years, mostly because of conflicting views about health and morals. 58 For example, concerns about debauchery and prostitution - real and imagined - run throughout the history of the bathhouse in all cultures. 59 Separating males and females does not fully address those worries.
Image: Scene of a bathhouse, c. 1470, painted by the Master of Anthony of Burgundy (Berlin Staatsbibliothek, Ms. Dep. Breslau 2, vol. 2, fol. 244).
View original image
View dithered image
Any plea for reviving public baths will also have to deal with the fear of contagious disease. For example, a “lockdown” of society, as many governments applied during the coronavirus pandemic in 2020 and 2021, is incompatible with public bathhouses. Such a measure only works when everybody has a private bathroom. 60 The link between communal bathing and health is complex. Science has confirmed many of the health benefits of cold, hot, and steam baths and has also shown the importance of social interaction. However, bringing people together will always raise health risks, too.
How to Build a Low-tech Bathhouse?
There’s another distinction between bathhouses built before and after the Industrial Revolution: preindustrial baths worked with renewable fuels, while industrial baths ran on fossil fuels. Many modern bathhouses had an on-site coal power plant, which heated the space and the water and provided electricity for lighting. Fossil fuel-powered bathhouses are more energy efficient than fossil fuel-powered private bathrooms, but we can do better than that.
A large bathhouse heated by a hypocaust system and large windows is still hard to beat as a carbon neutral technology, at least based on sustainable wood production. 6162 However, biomass combustion creates air pollution, while we could also power a bathhouse with renewable energy sources that don’t have that problem. The most apparent solution for space and water heating is flat plate solar collectors in which the sun heats water. Heat-generating windmills are a low-tech alternative to solar thermal collectors in less sunny climates. 63 Other potential heat sources are geothermal energy and factory waste heat.
Fossil fuel-powered bathhouses are more energy efficient than fossil fuel-powered private bathrooms, but we can do better than that.
A solar or wind-powered bathhouse’s biggest drawback is its dependency on favorable weather conditions. To compensate for that, solar or wind power can be combined with thermal energy storage, such as insulated water tanks. Storing heat in a thermal mass for longer periods is much cheaper and more sustainable than storing electricity in chemical batteries. However, it requires space that only communal bathing can offer. Steam baths and saunas are more difficult to disconnect from biomass combustion, but some innovative examples exist. 64
Clustering bathing facilities in a shared infrastructure also creates sufficient space for a bathhouse to have extensive heat insulation (a decisive factor in energy consumption) and provide for its water supply (for example, by catching and storing rainwater) as well as wastewater treatment (for example through phytoremediation using plants).
Architects have applied some of these ideas in countries where public baths are still used. For example, in a mountain village in China, a community bathhouse for 5,000 people is largely off-the-grid, pumping up its water from a well, heating it with solar collectors, and filtering the run-off wastewater from the showers and the toilets in basins filled with bamboo plants. 65
Image: This bathhouse in China has 24 showers and serves a community of 5,000 residents. It recycles the waste-water with bamboo plants. Source: BAO Architects.
View original image
View dithered image
However, a public bathhouse also fits the more high-tech vision of a centralized energy infrastructure based on solar PV panels and wind turbines that provide electricity. In such a configuration, public bathhouses could absorb excess electricity during abundantly sunny or windy days. Rather than curtailing the electricity from surplus solar and wind power, we could use it to power electric heat pumps and store the heat in the thermal mass of public baths. 66 While this approach is less resource-efficient than off-grid bathhouses operating without electricity, it still beats a scenario in which a centralized renewable power grid supplies energy to many private bathrooms.
Kris De Decker
Many thanks to Jonas Görgen and Elizabeth Shove for their feedback on an earlier version of this article.
Marie Verdeil and Roel Roscam Abbing contributed to the selection of images.
| 2024-11-08T17:50:54 | null | train |
42,036,957 | PaulHoule | 2024-11-03T23:24:55 | New survey puts human face on pollution caused by U.S. wood pellet mills | null | https://news.mongabay.com/2024/10/new-survey-puts-human-face-on-pollution-caused-by-u-s-wood-pellet-mills/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,036,963 | nobodywasishere | 2024-11-03T23:25:38 | Brooklyn's Map, Explained [video] | null | https://www.youtube.com/watch?v=2zVAslOVQUM | 2 | 0 | null | null | null | no_article | null | null | null | null | 2024-11-07T22:19:09 | null | train |
42,036,964 | somefries | 2024-11-03T23:25:40 | Show HN: Extract iMessage Attachments and Links into Organized Folders | I created a simple shell (zsh) script to help macOS users extract attachments (photos, videos, audio files) and URLs from their iMessages. The script pulls data directly from the Messages database (chat.db), organizes attachments into folders named after each contact or group conversation, and compiles all shared links into CSV files.<p>This tool can be useful for anyone looking to back up or organize files shared over iMessage without needing the entire conversation history. It also handles macOS's complex local storage structure for attachments.<p>No sign-ups or dependencies beyond macOS and SQLite. Just run the script, and it’ll create a neat export folder on your desktop. Would love feedback on any edge cases you encounter! | https://gist.github.com/rmtbb/c77deb7a697b032d374c57cf96aa98c8 | 25 | 5 | [
42045573,
42037589,
42037521,
42037038
] | null | null | null | null | null | null | null | null | null | train |
42,036,977 | gschoeni | 2024-11-03T23:27:39 | null | null | null | 1 | null | [
42036978
] | null | true | null | null | null | null | null | null | null | train |
42,036,985 | null | 2024-11-03T23:29:20 | null | null | null | null | null | null | [
"true"
] | true | null | null | null | null | null | null | null | train |
42,036,989 | david_shi | 2024-11-03T23:29:39 | Memes, Markets, and Machines | null | https://arxiv.org/abs/2410.23794 | 3 | 1 | [
42037289
] | null | null | null | null | null | null | null | null | null | train |
42,037,020 | ata_aman | 2024-11-03T23:34:01 | null | null | null | 1 | null | null | null | true | null | null | null | null | null | null | null | train |
42,037,021 | belfalas | 2024-11-03T23:34:12 | Microservices don't make sense (part 1) | null | https://hundredmondays.substack.com/p/microservices-dont-make-sense-part | 3 | 0 | null | null | null | no_error | Microservices don’t make sense [part 1] | 2024-11-02T23:54:09+00:00 | Julian Warszawski | It is embarrassing how long it took me to formulate this conclusion. The evidence has always been there. A decade of hysteric enthusiasm didn’t help. Critical views popping here and there suffered the same problem as the original proposition - they were based on individuals opinions, anecdotal evidence and loose definitions. I’m not aspiring to turn this discourse into a formal argument, but I will at least attempt to avoid the logical fallacies. To achieve that we have to reduce our definitions to an absolute minimum. Let’s go people!Let’s start with an example of a simple local function call. I chose Rust notation for its clarity, but all the examples are transferable to any mainstream language.fn module1(){ let result = module2(Type1::new(), Type2::new()); // do something with the result}// somewhere else in the codebase:fn module2(arg1: Type1, arg2: Type2): ReturnType { let value = ReturnType::new() return value;}A function module1 calls a function module2. Module1 passes two arguments to module2. Types of these arguments are Type1 and Type2 respectively. Module1 waits until module2 returns, assigns its return value to the result value and continues its execution. There are some language-specific operations on the stack as it happens, but these details are not important.You are about to close this and read something else, aren’t you? Please don’t. Awkward as it is, these basics have to be stated to illustrate the problem. Sorry.Let’s make some assumptions:none of these functions perform remote callsboth functions are executed in the same runtime (be it an interpreter, virtual machine or an operating system)the language and runtime we use have basic productivity tools, like compiler/static analyzer, debugger and IDE capable of navigation and basic refactoringNow we will review a bunch of tasks one might undertake with the above code.Task: Navigate from module1 to module2 codeUse ‘jump to definition’ featureTask: Change the body of module1 or module2Code, save, compile, test, releaseTask: Remove a field from module2 input argUse ‘safe delete’ to remove the field and all its uses throughout the codebaseTask: Change module2 return typeUpdate the type, and how it is used for all references to module2 with safe refactoringTask: Break module2 into two separate functionsRearrange module2 code and its clients. Save, compile, test, release.Task: Move module2 to be a member of a different classUse ‘move to’ feature.Task: Test interaction between module1 and module2Write a unit test that runs module1 and validates that effects of module2 are as expected.Task: Debug the execution flow of module1 and into module2Use either a local or remote debugger with breakpoints and step features.Those actions - what do they have in common? They are unremarkable. Something a single dev or a pairing duo would execute multiple times a day. Fast, local, atomic, forgiving. Just cheap. With those tenets you can achieve a state of flow. You can do rapid experimentation. You can have confidence to continuously refactor towards the most optimal structure.You know what comes next, don’t you? There is a reason why we called these functions module1 and module2. Let us then transfer this little trivial system into the world of microservices.Here Module1 and Module2 are separate services communicating by exchanging messages over the network using some protocol. The protocol defines how messages are packaged, serialized, secured, deduplicated and retried. All that in order to assure some level or reliability.We will now quickly list steps required for this synchronous exchange of messages to happen. We will assume the common practice of upstream services providing client libraries to their downstream counterparts.Module1 builds a Request object and calls a method of Module2 client libraryModule2 client serializes the Request objectModule2 client uses protocol of choice to send the message over the networkMessage is broken into a series of IP packets as it travels over the networkModule2 runtime receives the packets and assembles the Request messageModule2 code deserializes the message into an objectModule2 performs necessary business logicModule2 builds a Response objectModule2 serializes the responseModule2 sends the response over the networkMessage is broken into a series of IP packets as it travels over the networkModule1 runtime receives packets and assembles the Response messageModule2 client library deserializes the message into a Response objectModule1 code receives the response and proceeds to further business logicThis is a simplified model that purposefully skips concerns such as encryption, load balancing and various layers of routing. Out of the 14 steps listed, items 1, 7, 8 and 14 have corresponding steps in the non-microservice solution.We will now map the activities listed previously into concrete actions for this architecture.Task: Navigate from module1 to module2 codeCheck Module2 client what is the name of the underlying API, then look that API endpoint up in the Module2 codebase either by full text search or with assistance of some custom tools. Might require some application level routing.Task: Change the body of module1 or module2Assuming no API changes, it involves change, save, compile/test and release.Task: Remove a field from module2 input argMark the field as deprecated and release a new version of Module2 client.Find all downstream services using this API.Modify Module1 code not to use deprecated fields. Deploy Module1 change.Change Module2 client and service to remove the field completely. Release a new version.Modify Module1 to use the new Module2 client and deploy.(this is one of a few ways to do it. The level of complication of other methods is similar)Task: Change module2 return typeThis could be accomplished by a similar process to that of removing a field. Although in practice we would release a whole new API with the new return type and have it running parallel to the old one. Then incorporate a switch in all downstream services and once the old API is not used anymore, shut it down.Task: Break module2 into two separate functionsThis would require defining two new APIs and following a similar process as the one in ‘change return type’ action.Task: Move module2 to be a member of a different classThis change is irrelevant in the context of microservices unless the remote access layer follows CORBA-style, or when we’re moving the API to another service. A rare case, but if necessary, we do it by rewriting the code into the codebase of a different service and following client migration procedure.Task: Test interaction between module1 and module2Spin up instances of both modules either as separate processes or separate containers.Alternatively, use a testing framework for one module assuming the availability of the other module under a given url. There are multiple techniques of integration testing of microservices.Task: Debug the execution flow of module1 and into module2While it is possible to connect two remote debuggers to two different services, in practice it is rarely used. We mostly rely on debug-level logging and provide enough request metadata to be able to trace the path of a request across network boundaries. With help of some log aggregation tools we can then recreate a scenario. If debug info is not granular enough, we might need to add more logging to code.A great deal of detail was omitted when describing the actions above. There are plenty of patterns, techniques and tools for achieving those goals for microservices. These are all moderate-to-highly complicated tasks taking any time between hours to weeks to complete. No way we can be confident about anyone’s ability to perform these tasks routinely, multiple times a day. Is that a problem? - we ask. Is it not just a matter of efficiency? Yes - some refactoring is harder - having to spend more time to restructure the code is an acceptable compromise given all the benefits we get in return. We will talk about those benefits in a moment. If we think that is indeed an acceptable tradeoff, it means we don’t really understand what we are trading off. Ability to restructure the internals of the system quickly enables experimentation. We can evaluate several approaches within a couple of days, run tests, select the winner based on empirical evidence. If we lose that ability, we are left with two alternatives:For each decision, consult experts, perhaps do a comparative analysis based on what we know and trust our collective intelligence.Go with the first solution that comes to mind and accept the risk that comes with it.Let’s say we want to make the best decision based on what we know. What do we know? Hard to generalize, but one thing can be said with absolute certainty: Of all the moments in the future where we could be making such a decision, this is the moment we know the least. There is no basis then to claim the decision will most probably be right. What if we don’t care? What if we accept the risk of the choice being wrong and roll with it? What if we decide to ‘move fast and break things’? What happens is exactly that. A moment arrives where we have sufficient context to say ‘that decision was not right, here is what we should do’. Except by that time we might have a system architecture established and built. Perhaps used in production. At this point changes like breaking down a single API call into multiple, changing its parameters or consolidating many APIs into one are all architectural changes. They require cross-team agreement, approvals, release coordination, deprecation plan, etc. All the while in the world of monolithic systems this would be a few minutes of work of a single engineer without bothering anyone else. To blow up simple decisions into complex and difficult processes is nonsensical, is ridiculous and frankly speaking is stupid. The only reason we don’t see it clearly is the layers of complexity one needs to shave off to establish the ground facts.And the more distributed our system is (i.e. more strongly exhibiting traits of microservices ‘architecture’) the more prevalent the problem is. We rob the engineers of an ability to ever get in the state of true flow or being able to see the ‘big picture’ just by looking at the code. The big picture now requires us to look at infrastructure topology and collate it with documentation of a multitude of APIs. There will be tools (expensive tools) that make it manageable for us. The state of flow is precious to individuals. People change jobs for that reason. What keeps them hooked on that flow-less situation? As engineers we take pride in solving problems and microservice architecture is very compelling because it introduces a lot of micro-problems that we can quickly solve and receive the mental gratification from such accomplishment. Problems like creating a spec for a service container cluster and seeing the cluster operational after a day of hard work. Writing a complicated distributed logging query and finding out where the request got stuck. Coding an application-level equivalent of a three-way join of data from three other services. These problems are hard enough and interesting enough to keep us happy-busy. We do not mind that in the grand scheme of things, the work we do is just toil. As a matter of fact, we don’t know it.There is this recurring theme dating back to medieval times of a person selling their soul to the devil in exchange for unimaginable riches. Now that we see the tradeoff we make by selecting microservices is as serious as giving away a soul, let us have a closer look at the ‘riches’ we are promised.I could have written a book just about debunking every single supposed benefit of microservices. But people don’t read books, so I need to be brief. The only point I want to show is that every single benefit is also achievable in monolithic systems, therefore it is not a benefit.Benefit 1: Teams can work independently on components of the system.Teams can work independently on components of a monolithic system as well. It is enough to define separate modules or namespaces to avoid name clashes and establish a basic contract in the form of public function or method signatures, which can easily evolve in the future.Benefit 2: Scalability - each microservice can be independently scaled.Monolithic systems can also be independently scaled. Ability to have worker pools, resource clusters and grid compute is not exclusive to microservices.Benefit 3: Better fault isolation - the failure of one service is less likely to cause a catastrophic outage.The first two benefits are at least true statements. This one is not. It seems we got ourselves two truths and a lie. If service A depends on service B and service B goes down, then service A goes down. Perhaps the idea is to have a high-availability cluster with failover? But then exactly the same can be done with a monolithic system - whip up a high availability cluster and a failover strategy.We still might be tempted to argue the merit of an idea based on its popularity. Thousands of tech companies doing MS can’t be wrong. We will dismiss this argument as a typical example of ad populum fallacy.How has such popularity been achieved? That is another interesting conundrum. There is an idea predating MS called Service Oriented Architecture. It is a very well documented, non-scientist-friendly and formally described set of patterns for creating distributed systems. The abuse of SOA by vendors and consultants during the era of “digital transformation” contributed to general skepticism towards it even though the framework itself is very well thought through and relevant to this day. It is possible that on the wave of that skepticism, the new approach has arrived. One that “felt” lightweight. Little did we know, “lightweight” really meant “vague”. It was wrong to admit a vague idea into technical conversations in the first place, but once it had been in, there was no coming back. People like vague ideas because they can act as experts. It is easier to market vague ideas, build tools and businesses around them. It is then important to strip those ideas off of their vagueness to the essential core and discuss its value proposition. As we have already seen, that proposition does not impress.We will explore this topic further soon. Stay tuned. | 2024-11-08T20:46:10 | en | train |
42,037,027 | justinl33 | 2024-11-03T23:36:02 | null | null | null | 1 | null | null | null | true | null | null | null | null | null | null | null | train |
42,037,055 | bentocorp | 2024-11-03T23:39:45 | null | null | null | 25 | null | [
42037228,
42037505,
42037658,
42037062
] | null | true | null | null | null | null | null | null | null | train |
42,037,086 | vinipolicena | 2024-11-03T23:45:50 | Michael Bolton: Testing Is Not Quality; Quality Is Not Testing | null | https://developsense.com/blog/2024/10/testing-is-not-quality-quality-is-not-testing | 3 | 1 | [
42037842
] | null | null | null | null | null | null | null | null | null | train |
42,037,110 | touggourt | 2024-11-03T23:49:09 | POV-Ray development is resuming | null | https://github.com/POV-Ray/povray | 2 | 2 | [
42037111,
42039190
] | null | null | no_error | GitHub - POV-Ray/povray: The Persistence of Vision Raytracer (POV-Ray) | null | POV-Ray | POV-Ray - The Persistence of Vision Raytracer
License
Forums
Bug Reports
Official Binaries
Building POV-Ray
IDE Versions
3D Modeller
Documentation
Contacting Us
Development Status (November 2024)
After a long break in releases of 3.8 beta test candidates, development is resuming, though not at the
pace of past releases. That said, we hope to have a 3.8 release ready before the end of the year.
One impediment we have yet to overcome is code signing for the Windows platform. Currently we have
no means of doing so as our previous key has expired. The difficulty is both cost and the need for
flexibility in verifying us as an organization. Despite the fact that we have a company registered
in Australia (Persistence of Vision Raytracer Pty. Ltd.) and it is visible on the ASIC website, it
is our experience that the verification process gets hung up by the fact the company doesn't sell
anything, have a street address, or have a phone number.
While we do not generally sign beta releases, it is our policy that official releases for the Windows
platform are expected to be signed.
License
As of version v3.7, the source for POV-Ray is licensed under the AGPL3. The documentation is under the
Creative Commons Attribution-Noncommercial-ShareAlike 2.5 license, and support files such
as SDL includes, macros, sample scenes and so forth are under the Creative Commons Attribution-ShareAlike
3.0 Unported License (see each file header for the specific one).
Forums
Discussion regarding POV-Ray is traditionally done via our forums at https://news.povray.org/.
These are also available via NNTP at news://news.povray.org/ for those preferring that.
Please note that the POV-Ray developers do not monitor all forums regularly. The ones we
tend to check most frequently are povray.general, povray.windows and povray.unix.
Bug Reports
It's generally a good idea to mention a bug in the forums prior to lodging a formal
report; this can save you some time if it's a non-bug or a solution is known. You
should also first check the known issues
to see if it has been reported already.
If you're sure something is a bug then please do lodge a bug report on the GitHub issues tracker.
Official Binaries
At this point in time, the only platform for which the project distributes pre-built
'official' (i.e. supported) binaries is Microsoft Windows. These may be
obtained via https://www.povray.org/download/..
Official Windows binaries of selected development versions are made available at
https://github.com/POV-Ray/povray/releases on a semi-irregular basis.
Building POV-Ray
At this point in time we generally recommend building from the latest version of the
latest-stable branch. Alternatively,
you may want to opt for a recent tagged version
to test-drive features that have been added since the latest stable release.
Please do not build directly from the master branch (or any other non-stable branch
for that matter), as versions from that branch may report ambiguous version numbers,
making it difficult to obtain version-specific support or report bugs in a useful manner.
POV-Ray should compile on any POSIX-compliant system with the required tools (please see
unix/README.md for build instructions),
on Microsoft Windows systems that have Visual Studio 2015 Update 1 or later installed (targeting
XP or later, both 32 and 64-bit - be sure to see windows/README.md,
otherwise your build will not work), and also on Mac systems (console mode only, using
an appropriately-modified version of the unix build - not currently provided by us).
If you are using an operating system with a package or ports system such as
Ubuntu or FreeBSD, you may like to check whether or not POV-Ray is available
via that route.
IDE versions
Currently the only version of POV-Ray with an IDE as such is the Windows build.
We do want to change that, though. With the release of POV-Ray v3.7 we have added
a clear split between the backend (renderer) and frontend (UI or console), along
with a C++ layer which abstracts this into a fairly easily-understood set of
classes (VFE, aka 'Virtual Front End').
We will offer support to those wishing to use this interface layer to integrate
POV-Ray into an open-source cross-platform IDE. We would also be interested in
hearing suggestions as to what we could base such an IDE on, should we go ahead
to integrate it ourselves.
Putting it another way: we consider getting a cross-platform IDE a high priority.
3D Modeller
POV-Ray does not currently have its own 3d modelling application (at least, not one
in a usable state). We do own the rights to the Moray modeller, which was formerly
commercial, but it needs a little work to get it working with v3.7 or later. It is also
Windows only (due to its use of MFC). Nevertheless we will be adding the source
to the repository at a future date.
Authors of open-source modellers with a compatible licence wishing to directly
integrate POV-Ray are welcome to contact us for support in doing so.
Documentation
When built and installed via the means provided in the source tree, all versions
of POV-Ray come with documentation. For the Unix build, this is in the form of a
manpage giving basic usage, and full HTML-based documentation. For the Windows
version, there is a HtmlHelp (.CHM) file provided.
The official location for the online documentation is https://www.povray.org/documentation/.
Further information, as well as online documentation for the current development
version, can be found at https://wiki.povray.org.
Contacting Us
We prefer that you contact us via the forums mentioned at the head of this document.
If the matter is one that requires direct email contact (and this generally will NOT
include tech support requests, though exceptions are made for package maintainers)
you may use the address listed at the bottom of https://www.povray.org/povlegal.html.
| 2024-11-07T23:02:16 | en | train |
42,037,112 | sthoward | 2024-11-03T23:49:15 | We put 1M files into DVC, Git-LFS, and Oxen.ai | null | https://docs.oxen.ai/features/performance | 7 | 4 | [
42054406,
42037113,
42040661
] | null | null | null | null | null | null | null | null | null | train |
42,037,120 | michaelengen | 2024-11-03T23:50:44 | Building My Resume in HTML Using Eleventy | null | https://michaelengen.com/posts/my-eleventy-resume/ | 85 | 70 | [
42038115,
42037551,
42037678,
42038366,
42039308,
42038685,
42037615,
42037922,
42037716,
42040490,
42038015,
42037881,
42039564,
42037708,
42038477,
42037541,
42037942,
42038148,
42038209,
42037935,
42037515,
42038293,
42038690,
42039106,
42038223,
42037595
] | null | null | null | null | null | null | null | null | null | train |
42,037,148 | yamrzou | 2024-11-03T23:55:59 | Hacking Life: Systematized Living and Its Discontents | null | https://hackinglife.mitpress.mit.edu/ | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,037,167 | pseudolus | 2024-11-04T00:00:14 | San Francisco Startup Sees Big Demand for Sleeping Pods That Cost $700 a Month | null | https://gizmodo.com/san-francisco-startup-sees-huge-demand-for-sleeping-pods-that-cost-700-a-month-2000520007 | 12 | 4 | [
42038559,
42038926,
42037378
] | null | null | null | null | null | null | null | null | null | train |
42,037,171 | lifeisstillgood | 2024-11-04T00:01:32 | The Telltale Traces of the US Military's New 'Bladed' Missile | null | https://www.bellingcat.com/resources/how-tos/2021/08/26/the-telltale-traces-of-the-us-militarys-new-bladed-missile-r9x/ | 4 | 2 | [
42045580,
42037340
] | null | null | null | null | null | null | null | null | null | train |
42,037,175 | truegoric | 2024-11-04T00:02:38 | SharpNEAT – evolving NN topologies and weights with a genetic algorithm | null | https://sharpneat.sourceforge.io/ | 8 | 2 | [
42042041,
42040886
] | null | null | cut_off | SharpNEAT Neuroevolution Framework | null | null |
Genetic Art
Genetic Art with SharpNEAT.
Holger Ferstl created this SharpNEAT based application that evolves images by allowing
a user to iteratively select their favourite from a page of candidate images.
Below is a selection of images created using this application; more images can be seen via Holger's
blog post (via the above link).
| 2024-11-08T12:13:05 | en | train |
42,037,227 | mooreds | 2024-11-04T00:13:49 | API Linting Levels | null | https://lornajane.net/posts/2024/api-linting-levels | 1 | 0 | null | null | null | no_error | API Linting Levels | null | lornajane | I’ve been thinking about API linting lately, partly because I work on a tool for API linting in my day job, and partly because I get quite a lot of questions from teams wanting to improve their API quality. The “best” ruleset depends entirely on your context, where you are in your API practice journey, and how much you want to invest in the API in question. I typically use a 4-levels model of API linting readiness, and I’m sharing them so that you can find yourself on the map and see where you might go from here.
This post is part of API Futures 2024, a series of posts by different contributors focused on the challenges for this year. My big wish is for everyone to find API tooling and configuration that fits their own context, which is why I’m publishing this linting levels post as part of the event.
Level 0: A valid API description
This sounds basic but a surprising number of public APIs either have no API description, or their OpenAPI description is actually invalid in some way. It may well work with the tools used in the producer organisation, but unless you supply a file that works with all other tools, there are limits to who can use and interact with your API.
Add some unopinionated validation to your CI workflow, and make sure that anyone who works on your API can also run those tools locally while they’re making changes – and you can graduate to the next level immediately :) Redocly has a rule for linting against the specification which is a great starting point (other API linting tools are available!). For the next level, there’s a great ruleset in the Redocly CLI Cookbook that you can copy and paste into your own projects; it aims to catch the things that match the declared data structure of OpenAPI and yet make absolutely no sense in the real world!
Level 1: Meets basic standards
Every API probably should have its own set of basic standards but I typically ask about the API linting rules that are already in place, such as:
– are there checks that security has been declared on every endpoint?
– is there useful metadata, such as a license and some contact information?
– does the API follow a design, such as RESTful API design, and how clear is that from the OpenAPI description?
– are consistent data formats used, such as cents (or equivalent) for money, ISO format dates, standard scientific units for measures?
Having some sort of API design, with some level of data handling, some supporting metadata, and some security practices in place is a level 1 API. Some APIs only need to be at level 1, such as a service with one or two endpoints that handles something non-critical such as newsletter signups. Sure, this API could be brought to a higher API standard and that could be enforced by tools and linting. But not every API needs the same level of investment or must comply with the same standards. Within an organisation, have a few defined levels, and make clear which APIs meet which standards.
Level 2: Has a consistent interface
There are few things more irritating than an inconsistent API, and yet a deeply consistent API interface is essentially an invisible feature. Users will very quickly feel comfortable and be productive using your API platform, but not being irritating is rarely given as customer feedback! So what are the ingredients for this developer happiness level of API standard? You can think of it as having two main elements: the philosophy, and the mechanics.
The mechanics is the simplest thing to get right. It means using plurals (or not), absolutely everywhere. Always using exactly the same variable name to refer to the same data, wherever it is used, and validating that data exactly the same way in both request and response for every endpoint. Having endpoints that are consistent in their shape and depth, and keeping common parameter patterns for features such as filtering or pagination the same everywhere. Adding linting rules to an existing API for this level of API standard can be quite tough, but add the rules you want to follow, with exceptions for any existing/legacy endpoints that aren’t compliant. Enabling the checks on the API, and acknowledging the parts that are known and shouldn’t fail the build, means you can automate the checks and add no more violations! The ignores list can also serve as a to-do list for things to work on, either by making backwards-compatible changes or to revisit if a new API version is in the works.
The philosophy part is a bit more difficult to think about but building on prior art in your APIs, for example by following established RESTful API design practices very tightly and adopting other standards that are already known and accepted. This approach means you don’t have too many decisions to make since you’re following existing and established standards, and the ideas may be familiar/supported by the users/tools that access your API. I particularly recommend looking into Hypertext Application Language (HAL) if you include links in the resources you return from your API endpoints, and RFC 9457: Problem details for APIs (replaces the better-known RFC 7807).
Level 3: Is a joy to use
We don’t describe developer experiences as “joy” often enough, but a really great API description definitely qualifies. If your API is your flagship product, or drives a lot of business value that is realised by strong integrations – this is the level you want to aim at. What’s funny about these top-level APIs is that their actual API design isn’t much different to the earlier levels, however the implementation and supporting materials are the special sauce.
To produce an API at this level, the API governance expands into a more holistic view of the API and what really makes an API experience joyful. This can be achieved with rich OpenAPI descriptions, and supporting documentation as the main pillars. I think there’s also an element here of discoverability, and that this aspect will only become more important in the future.
Enriching OpenAPI descriptions can take many forms. Make the most of the description fields; these support Markdown so don’t be afraid to add links, lists, or whatever else would help the user. From the very top level, where info.description sets the scene and purpose for the whole API, through the individual endpoint descriptions and down to the individual parameter and schema fields, the descriptions are the magic sauce. Explain not just what the thing is, but also what it does, and why the user would want to do that. Enrich also with meaningful and illustrative examples, using (culturally varied) example data that represents something a user really would be doing, rather than “foo” or “bar”. A project name could be “holiday_planning” and an email address “[email protected]”, and using values like this does make a more successful and happier end user.
The documentation is not just the reference documentation either. I haven’t seen linting rules for this, so perhaps it’s a little out of scope, but adding meaningful onboarding documentation or getting started guides, and tutorials for the most common tasks in an API are both excellent additions that make a good API into a great API.
Make your API next-level
Don’t be put off by API standards tooling that comes with big opinions of its own. Reflecting on what your API needs, and what your organisation can support, will help you find which level you are on and where you want to be and set your API projects up for success. Tune the API linting rules to get the support you need, but don’t be afraid to turn things off that aren’t important to you! All the tools come with default rules, but every situation is different so take the time to adjust it for your context rather than gritting your teeth and dealing with someone else’s ideals. | 2024-11-08T17:58:41 | en | train |
42,037,239 | null | 2024-11-04T00:16:09 | null | null | null | null | null | null | [
"true"
] | null | null | null | null | null | null | null | null | train |
42,037,246 | null | 2024-11-04T00:17:03 | null | null | null | null | null | null | [
"true"
] | null | null | null | null | null | null | null | null | train |
42,037,251 | johndavid9991 | 2024-11-04T00:18:30 | Ask HN: Your thoughts on Linus Torvalds' view on AI: 90% marketing, 10% reality? | Linus Torvalds reportedly grimaced as labelled the current state of the AI market as “90% marketing and 10% reality.”<p>“I think AI is really interesting, and I think it is going to change the world," he noted, "and, at the same time, I hate the hype cycle so much that I really don’t want to go there."<p>"So my approach to AI right now is I will basically ignore it because I think the whole tech industry around AI is in a very bad position," Torvalds added, "however, it seems like there is almost too much AI BS around for the Fin to tolerate."<p>https://www.techradar.com/pro/linus-torvalds-slams-ai-as-90-percent-marketing-and-10-percent-reality | null | 13 | 9 | [
42037404,
42038076,
42040253,
42037694,
42037584
] | null | null | null | null | null | null | null | null | null | train |
42,037,260 | yamrzou | 2024-11-04T00:19:24 | Reasonable Person Principle | null | https://www.cs.cmu.edu/~weigand/staff/ | 74 | 69 | [
42038150,
42037826,
42037673,
42038670,
42037823,
42039685,
42038455,
42037946,
42038313
] | null | null | null | null | null | null | null | null | null | train |
42,037,305 | impish9208 | 2024-11-04T00:25:36 | Divorce applications wrongly approved after computer error, high court hears | null | https://www.theguardian.com/law/2024/oct/31/divorce-applications-wrongly-approved-computer-error-high-court | 3 | 0 | null | null | null | no_error | Divorce applications wrongly approved after computer error, high court hears | 2024-10-31T08:34:51.000Z | Geneva Abdul | Dozens of divorce applications were wrongly approved due to a computer error, the high court has heard.A hearing in London on Wednesday was told that 79 divorces were incorrectly approved after the applications were submitted a day before the law allows. An online system failed to detect that the submissions came a year after marriage, when the law only permits divorces from a year and a day.Lawyers for the justice secretary have asked the court to rule that the divorces are “voidable” as opposed to “void”, meaning they would still stand, claiming that voiding the divorces would have “highly unfortunate and highly unwelcome” consequences for the couples concerned.The court was told that between April 2022, when the validation system of the online portal was introduced, and April 2024, a total of 96 divorce applications were made on the first anniversary of marriage. Of these, a final divorce order was granted in 79 cases.None of the divorcees appeared at the hearing and were not represented. The court heard that several respondents had expressed “significant distress” in the possibility they may not be legally divorced from their former partners. Some of the divorcees had either since remarried or were planning to, the court heard.In a written submission, Sir James Eadie KC said the undoing of final divorce orders had “significant legal and practical consequences”. If the orders are void, he added, the impact would be significant on those who had either remarried or had financial orders after the affected divorces.skip past newsletter promotionafter newsletter promotionHe said: “The undoing of final divorce orders has the consequence that separated couples who were, and thought they were, divorced will be held to still be married.”Eadie said of the system’s error, “If there was a flaw, it was a genuine system flaw” , adding that it was a “minor kind” and that all the cases met the criteria for divorce.The judgment will be given in writing at a later date.Earlier this year, the wrong couple were divorced by mistake after a computer error made by solicitors at a leading law firm. However, the order was not overturned.Lawyers mistakenly used an online portal to apply for a final divorce order for a couple when they had intended to apply for divorce for another client. The order, granted through the online system, divorced the wrong couple within 21 minutes. | 2024-11-08T02:05:55 | en | train |
42,037,353 | thunderbong | 2024-11-04T00:35:35 | Welcome to the Jungle | null | https://anderssundman.medium.com/welcome-to-the-jungle-b0864a76d7f0 | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,037,367 | 8bitsrule | 2024-11-04T00:39:59 | 1940 'affordable' home recording – the Wilcox-Gay 'Recordio' | null | https://onetuberadio.com/2015/01/28/the-wilcox-gay-recordio-1940-home-recording/ | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,037,370 | zhengiszen | 2024-11-04T00:40:26 | null | null | null | 1 | null | null | null | true | null | null | null | null | null | null | null | train |
42,037,396 | abhinavk | 2024-11-04T00:45:22 | What has case distinction but is neither uppercase nor lowercase? (OldNewThing) | null | https://devblogs.microsoft.com/oldnewthing/20241031-00/?p=110443 | 14 | 0 | [
42040656
] | null | null | no_error | What has case distinction but is neither uppercase nor lowercase? - The Old New Thing | 2024-10-31T14:00:00+00:00 | Raymond Chen |
If you go exploring the Unicode Standard, you may be surprised to find that there are some characters that have case distinction yet are themselves neither uppercase nor lowercase.
Oooooh, spooky.
In other words, it is a character c with the properties that
toUpper(c) ≠ toLower(c), yet
c ≠ toUpper(c) and c ≠ toLower(c).
Congratulations, you found the mysterious third case: Title case.
There are some Unicode characters that occupy a single code point but represent two graphical symbols packed together. For example, the Unicode character dz (U+01F1 LATIN SMALL LETTER DZ), looks like two Unicode characters placed next to each other: dz (U+0064 LATIN SMALL LETTER D followed by U+007A LATIN SMALL LETTER Z).
These diagraphs are characters in the alphabets of some languages, most notably Hungarian. In those languages, the diagraph is considered a separate letter of the alphabet. For example, the first ten letters of the Hungarian alphabet are¹
a
á
b
c
cs
d
dz
dzs
e
é
These digraphs (and one trigraph) have three forms.
Form
Result
Uppercase
DZ
Title case
Dz
Lowercase
dz
Unicode includes four diagraphs in its encoding.
Uppercase
Title case
Lowercase
DŽ
Dž
dž
LJ
Lj
lj
NJ
Nj
nj
DZ
Dz
dz
But wait, we have a Unicode code point for the dz digraph, but we don’t have one for the cs digraph or the dzs trigraph. What’s so special about dz?
These digraphs owe their existence in Unicode not to Hungarian but to Serbo-Croatian. Serbo-Croatian is written in both Latin script (Croatian) and Cyrillic script (Serbian), and these digraphs permit one-to-one transliteration between them.¹
Just another situation where the world is more complicated than you think. You thought you understood uppercase and lowercase, but there’s another case in between that you didn’t know about.
Bonus chatter: The fact that dz is treated as a single letter in Hungarian means that if you search for “mad”, it should not match “madzag” (which means “string”) because the “dz” in “madzag” is a single letter and not a “d” followed by a “z”, no more than “lav” should match “law” just because the first part of the letter “w” looks like a “v”. Another surprising result if you mistakenly use a literal substring search rather than a locale-sensitive one. We’ll look at locale-sensitive substrings searches next time.
¹ I got this information from the Unicode Standard, Version 15.0, Chapter 7: “Europe I”, Section 7.1: “Latin”, subsection “Latin Extended-B: U+0180-U+024F”, sub-subsection “Croatian Digraphs Matching Serbian Cyrillic Letters.”
Author
Raymond has been involved in the evolution of Windows for more than 30 years. In 2003, he began a Web site known as The Old New Thing which has grown in popularity far beyond his wildest imagination, a development which still gives him the heebie-jeebies. The Web site spawned a book, coincidentally also titled The Old New Thing (Addison Wesley 2007). He occasionally appears on the Windows Dev Docs Twitter account to tell stories which convey no useful information. | 2024-11-08T13:36:43 | en | train |
42,037,417 | thunderbong | 2024-11-04T00:49:54 | C Until It Is No Longer C | null | https://aartaka.me/c-not-c | 1 | 0 | [
42040648
] | null | null | null | null | null | null | null | null | null | train |
42,037,422 | popshort | 2024-11-04T00:50:38 | null | null | null | 1 | null | [
42037423
] | null | true | null | null | null | null | null | null | null | train |
42,037,434 | sandwichsphinx | 2024-11-04T00:53:20 | Interlock – The new ransomware targeting FreeBSD servers | null | https://www.bleepingcomputer.com/news/security/meet-interlock-the-new-ransomware-targeting-freebsd-servers/ | 4 | 0 | [
42040642
] | null | null | null | null | null | null | null | null | null | train |
42,037,440 | mountainview | 2024-11-04T00:54:06 | Allegro: Open the Black Box of Commercial-Level Video Generation Model | null | https://rhymes.ai/blog-details/allegro-advanced-video-generation-model | 2 | 0 | null | null | null | no_title | null | null | null | null | 2024-11-08T05:48:41 | null | train |
42,037,456 | PaulHoule | 2024-11-04T00:57:33 | Achieving Parallel Performance and Portability Across CPU and GPU Architectures | null | https://www.mdpi.com/2078-2489/15/11/673 | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,037,478 | aard | 2024-11-04T01:02:18 | null | null | null | 1 | null | null | null | true | null | null | null | null | null | null | null | train |
42,037,500 | bookofjoe | 2024-11-04T01:05:42 | Headlights are too bright! But US experts say they're not bright enough | null | https://www.theguardian.com/global/2024/oct/31/headlights-too-bright | 10 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,037,612 | todsacerdoti | 2024-11-04T01:31:21 | Writing integration tests for a Go CLI application | null | https://lucapette.me/writing/writing-integration-tests-for-a-go-cli-application/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,037,622 | djha-skin | 2024-11-04T01:33:09 | Startup Advice | null | https://anandsanwal.me/startup-advice/ | 1 | 0 | [
42040631
] | null | null | null | null | null | null | null | null | null | train |
42,037,638 | MaskRay | 2024-11-04T01:37:09 | Tinkering with Neovim | null | https://maskray.me/blog/2024-11-02-tinkering-with-neovim | 2 | 1 | [
42037643,
42040627
] | null | null | null | null | null | null | null | null | null | train |
42,037,644 | aard | 2024-11-04T01:38:41 | People Fake Productivity at Work. Here's What to Measure Instead | null | https://www.forbes.com/sites/tracybrower/2024/09/22/why-people-fake-productivity-in-the-workplace/ | 4 | 1 | [
42038363,
42040625
] | null | null | null | null | null | null | null | null | null | train |
42,037,648 | rgdfgfdgh | 2024-11-04T01:39:04 | null | null | null | 1 | null | null | null | true | null | null | null | null | null | null | null | train |
42,037,662 | aard | 2024-11-04T01:42:06 | null | null | null | 1 | null | null | null | true | null | null | null | null | null | null | null | train |
42,037,679 | pseudolus | 2024-11-04T01:44:11 | Can computers think? No they can't actually do anything | null | https://aeon.co/essays/can-computers-think-no-they-cant-actually-do-anything | 5 | 0 | [
42040624
] | null | null | null | null | null | null | null | null | null | train |
42,037,684 | apsec112 | 2024-11-04T01:45:54 | What I learned from 130 hours in a Waymo | null | https://www.mattbell.us/what-i-learned-from-130-hours-in-a-waymo/ | 4 | 0 | [
42040621
] | null | null | null | null | null | null | null | null | null | train |
42,037,685 | aard | 2024-11-04T01:45:55 | Software estimates have never worked and never will | null | https://world.hey.com/dhh/software-estimates-have-never-worked-and-never-will-a41a9c71 | 11 | 11 | [
42038107,
42038324,
42037754
] | null | null | missing_parsing | Software estimates have never worked and never will | null | null |
Since the dawn of computing, humans have sought to estimate how long it takes to build software, and for just as long, they've consistently failed. Estimating even medium-sized projects is devilishly difficult, and estimating large projects is virtually impossible. Yet the industry keeps insisting that the method that hasn't worked for sixty years will definitely work on this next project, if we all just try a little harder. It's the definition of delusional.The fundamental problem is that as soon as a type of software development becomes so routine that it would be possible to estimate, it turns into a product or a service you can just buy rather than build. Very few people need to build vanilla content management systems or e-commerce stores today, they just use WordPress or Shopify or one of the alternatives. Thus, the bulk of software development is focused on novel work.But the thing about novel work is that nobody knows exactly what it should look like until they start building. For just as long as software industry has been failing to estimate the work, it's also been deluding itself into thinking that you can specify novel work upfront, and produce something people actually want.Yet we've also tried that many times before! And nobody cared for the outcome. Because it invariably didn't end up solving the real problems. The ones you could only articulate after building half of a wrong solution, changing direction, and then coming up with something better.It's time to accept this. Smart programmers have tried for decades, and they have repeatedly failed, just as folks fail today, when we try to cut against the grain of human ingenuity, and insist that software needs estimation.The solution is not to try harder nor to hope that this time is somehow different. It's to change tactics. Give up on estimates, and embrace the alternative method for making software by using budgets, or appetites, as we call them in our Shape Up methodology.It turns out that programmers are actually surprisingly good at delivering great software on time, if you leave the scope open to negotiation during development. You're not going to get exactly what you asked for, but you wouldn't want that anyway. Because what you asked for before you began building was based on the absolute worst understanding of the problem.Great software is the product of trade-offs and concessions made while making progress. That's how you cut with the grain of human nature. It's the core realization that's been driving us for decades at 37signals, and which has resulted in some wonderful products built by small teams punching way above their weight. We've incorporated it into Shape Up, but whether you use a specific methodology or not, giving up on estimates can help you ship better and sooner.
| 2024-11-08T17:36:33 | null | train |
42,037,696 | rsaz | 2024-11-04T01:48:03 | Open Fire Cooking – Mechanical Spit Jack [video] | null | https://www.youtube.com/watch?v=i0Nxpve927g | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,037,702 | sandwichsphinx | 2024-11-04T01:49:25 | Technical Glossary | null | https://www.appliedmaterials.com/us/en/glossary.html | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,037,703 | trytrycc | 2024-11-04T01:49:26 | null | null | null | 3 | null | null | null | true | null | null | null | null | null | null | null | train |
42,037,723 | xbmcuser | 2024-11-04T01:54:11 | Why is Mustard Oil Banned in US and Europe? [video] | null | https://www.youtube.com/watch?v=D2Htv9k1Rgg | 2 | 1 | [
42038120
] | null | null | null | null | null | null | null | null | null | train |
42,037,741 | FpUser | 2024-11-04T02:02:10 | null | null | null | 1 | null | null | null | true | null | null | null | null | null | null | null | train |
42,037,743 | thunderbong | 2024-11-04T02:02:29 | Adding IPv6 to My Home Network (2024-11-03) | null | https://code.jeremyevans.net/2024-11-03-adding-ipv6-to-my-home-network.html | 50 | 54 | [
42038950,
42039536,
42038931,
42039823,
42039338,
42039780,
42039981
] | null | null | null | null | null | null | null | null | null | train |
42,037,750 | wglb | 2024-11-04T02:04:18 | Ham radio enthusiasts who help keep the NYC Marathon running smoothly | null | https://www.popsci.com/technology/ham-radio-new-york-marathon/ | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
42,037,751 | lifeplusplus | 2024-11-04T02:04:19 | null | null | null | 2 | null | null | null | true | null | null | null | null | null | null | null | train |
42,037,768 | null | 2024-11-04T02:08:39 | null | null | null | null | null | [
42037936
] | [
"true"
] | null | null | null | null | null | null | null | null | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.