10 interesting stories served every morning and every evening.

1 654 shares, 26 trendiness


When prompted with an idea, ChatGPT will au­to­mat­i­cally gen­er­ate tai­lored, de­tailed prompts for DALL·E 3 that bring your idea to life. If you like a par­tic­u­lar im­age, but it’s not quite right, you can ask ChatGPT to make tweaks with just a few words.

DALL·E 3 will be avail­able to ChatGPT Plus and Enterprise cus­tomers in early October. As with DALL·E 2, the im­ages you cre­ate with DALL·E 3 are yours to use and you don’t need our per­mis­sion to reprint, sell or mer­chan­dise them.


Read the original on openai.com »

2 559 shares, 23 trendiness

Sync for modern apps

Craft how data syncs on and off onto your app us­ing Shapes.

Shapes al­low you to man­age dy­namic par­tial repli­ca­tion be­tween Postgres in the cloud and SQLite in the lo­cal app.


Read the original on electric-sql.com »

3 444 shares, 52 trendiness

Today The UK Parliament Undermined The Privacy, Security, And Freedom Of All Internet Users

The U. K. Parliament has passed the Online Safety Bill (OSB), which says it will make the U.K. the safest place” in the world to be on­line. In re­al­ity, the OSB will lead to a much more cen­sored, locked-down in­ter­net for British users. The bill could em­power the gov­ern­ment to un­der­mine not just the pri­vacy and se­cu­rity of U.K. res­i­dents, but in­ter­net users world­wide.

A clause of the bill al­lows Ofcom, the British tele­com reg­u­la­tor, to serve a no­tice re­quir­ing tech com­pa­nies to scan their users–all of them–for child abuse con­tent. This would af­fect even mes­sages and files that are end-to-end en­crypted to pro­tect user pri­vacy. As en­acted, the OSB al­lows the gov­ern­ment to force com­pa­nies to build tech­nol­ogy that can scan re­gard­less of en­cryp­tion–in other words, build a back­door.

These types of client-side scan­ning sys­tems amount to Bugs in Our Pockets,” and a group of lead­ing com­puter se­cu­rity ex­perts has reached the same con­clu­sion as EFF–they un­der­mine pri­vacy and se­cu­rity for every­one. That’s why EFF has strongly op­posed the OSB for years.

It’s a ba­sic hu­man right to have a pri­vate con­ver­sa­tion. This right is even more im­por­tant for the most vul­ner­a­ble peo­ple. If the U. K. uses its new pow­ers to scan peo­ple’s data, law­mak­ers will dam­age the se­cu­rity peo­ple need to pro­tect them­selves from ha­rassers, data thieves, au­thor­i­tar­ian gov­ern­ments, and oth­ers. Paradoxically, U.K. law­mak­ers have cre­ated these new risks in the name of on­line safety.

The U. K. gov­ern­ment has made some re­cent state­ments in­di­cat­ing that it ac­tu­ally re­al­izes that get­ting around end-to-end en­cryp­tion is­n’t com­pat­i­ble with pro­tect­ing user pri­vacy. But given the text of the law, nei­ther the gov­ern­men­t’s pri­vate state­ments to tech com­pa­nies, nor its weak pub­lic as­sur­ances, are enough to pro­tect the hu­man rights of British peo­ple or in­ter­net users around the world.

Online plat­forms will be ex­pected to re­move con­tent that the U. K. gov­ern­ment views as in­ap­pro­pri­ate for chil­dren. If they don’t, they’ll face heavy penal­ties. The prob­lem is, in the U.K. as in the U.S., peo­ple do not agree about what type of con­tent is harm­ful for kids. Putting that de­ci­sion in the hands of gov­ern­ment reg­u­la­tors will lead to politi­cized cen­sor­ship de­ci­sions.

The OSB will also lead to harm­ful age-ver­i­fi­ca­tion sys­tems. This vi­o­lates fun­da­men­tal prin­ci­ples about anony­mous and sim­ple ac­cess that has ex­isted since the be­gin­ning of the Internet. You should­n’t have to show your ID to get on­line. Age-gating sys­tems meant to keep out kids in­vari­ably lead to adults los­ing their rights to pri­vate speech, and anony­mous speech, which is some­times nec­es­sary.

In the com­ing months, we’ll be watch­ing what type of reg­u­la­tions the U. K. gov­ern­ment pub­lishes de­scrib­ing how it will use these new pow­ers to reg­u­late the in­ter­net. If the reg­u­la­tors claim their right to re­quire the cre­ation of dan­ger­ous back­doors in en­crypted ser­vices, we ex­pect en­crypted mes­sag­ing ser­vices to keep their promises and with­draw from the U.K. if that na­tion’s gov­ern­ment com­pro­mises their abil­ity to pro­tect other users.


Read the original on www.eff.org »

4 436 shares, 17 trendiness

Introducing runes

In 2019, Svelte 3 turned JavaScript into a re­ac­tive lan­guage. Svelte is a web UI frame­work that uses a com­piler to turn de­clar­a­tive com­po­nent code like this…

…into tightly op­ti­mized JavaScript that up­dates the doc­u­ment when state like count changes. Because the com­piler can see’ where count is ref­er­enced, the gen­er­ated code is highly ef­fi­cient, and be­cause we’re hi­jack­ing syn­tax like let and = in­stead of us­ing cum­ber­some APIs, you can write less code.

A com­mon piece of feed­back we get is I wish I could write all my JavaScript like this’. When you’re used to things in­side com­po­nents mag­i­cally up­dat­ing, go­ing back to bor­ing old pro­ce­dural code feels like go­ing from colour to black-and-white.

Svelte 5 changes all that with runes, which un­lock uni­ver­sal, fine-grained re­ac­tiv­ity.

Even though we’re chang­ing how things work un­der the hood, Svelte 5 should be a drop-in re­place­ment for al­most every­one. The new fea­tures are opt-in — your ex­ist­ing com­po­nents will con­tinue to work.

We don’t yet have a re­lease date for Svelte 5. What we’re show­ing you here is a work-in-progress that is likely to change!

A let­ter or mark used as a mys­ti­cal or magic sym­bol.

Runes are sym­bols that in­flu­ence the Svelte com­piler. Whereas Svelte to­day uses let, =, the ex­port key­word and the $: la­bel to mean spe­cific things, runes use func­tion syn­tax to achieve the same things and more.

For ex­am­ple, to de­clare a piece of re­ac­tive state, we can use the $state rune:

At first glance, this might seem like a step back — per­haps even un-Svelte-like. Isn’t it bet­ter if let count is re­ac­tive by de­fault?

Well, no. The re­al­ity is that as ap­pli­ca­tions grow in com­plex­ity, fig­ur­ing out which val­ues are re­ac­tive and which aren’t can get tricky. And the heuris­tic only works for let de­c­la­ra­tions at the top level of a com­po­nent, which can cause con­fu­sion. Having code be­have one way in­side .svelte files and an­other in­side .js can make it hard to refac­tor code, for ex­am­ple if you need to turn some­thing into a store so that you can use it in mul­ti­ple places.

With runes, re­ac­tiv­ity ex­tends be­yond the bound­aries of your .svelte files. Suppose we wanted to en­cap­su­late our counter logic in a way that could be reused be­tween com­po­nents. Today, you would use a cus­tom store in a .js or .ts file:

tsim­port { writable } from svelte/store’;

ex­port func­tion cre­ate­Counter() { const { sub­scribe, up­date } = writable(0);

re­turn { subscribe, increment: () => up­date((n) => n + 1) };}

Because this im­ple­ments the store con­tract — the re­turned value has a sub­scribe method — we can ref­er­ence the store value by pre­fix­ing the store name with $:

This works, but it’s pretty weird! We’ve found that the store API can get rather un­wieldy when you start do­ing more com­plex things.

With runes, things get much sim­pler:

im­port { writable } from svelte/store’;

ex­port func­tion cre­ate­Counter() {

const { sub­scribe, up­date } = writable(0);

let count = $state(0);

re­turn {


in­cre­ment: () => up­date((n) => n + 1)

get count() { re­turn count },

in­cre­ment: () => count += 1

Note that we’re us­ing a get prop­erty in the re­turned ob­ject, so that counter.count al­ways refers to the cur­rent value rather than the value at the time the func­tion was called.

Today, Svelte uses com­pile-time re­ac­tiv­ity. This means that if you have some code that uses the $: la­bel to re-run au­to­mat­i­cally when de­pen­den­cies change, those de­pen­den­cies are de­ter­mined when Svelte com­piles your com­po­nent:

This works well… un­til it does­n’t. Suppose we refac­tored the code above:

tsconst mul­ti­ply­By­Height = (width) => width * height;Pa­ra­me­ter width’ im­plic­itly has an any’ type.Can­not find name height’.70062304Parameter width’ im­plic­itly has an any’ type.Can­not find name height’.$: area = mul­ti­ply­By­Height(width);Can­not find name area’.Cannot find name width’.23042304Cannot find name area’.Cannot find name width’.

Because the $: area = … de­c­la­ra­tion can only see’ width, it won’t be re­cal­cu­lated when height changes. As a re­sult, code is hard to refac­tor, and un­der­stand­ing the in­tri­ca­cies of when Svelte chooses to up­date which val­ues can be­come rather tricky be­yond a cer­tain level of com­plex­ity.

Svelte 5 in­tro­duces the $derived and $effect runes, which in­stead de­ter­mine the de­pen­den­cies of their ex­pres­sions when they are eval­u­ated:

As with $state, $derived and $effect can also be used in your .js and .ts files.

Like every other frame­work, we’ve come to the re­al­i­sa­tion that Knockout was right all along.

Svelte 5′s re­ac­tiv­ity is pow­ered by sig­nals, which are es­sen­tially what Knockout was do­ing in 2010. More re­cently, sig­nals have been pop­u­larised by Solid and adopted by a mul­ti­tude of other frame­works.

We’re do­ing things a bit dif­fer­ently though. In Svelte 5, sig­nals are an un­der-the-hood im­ple­men­ta­tion de­tail rather than some­thing you in­ter­act with di­rectly. As such, we don’t have the same API de­sign con­straints, and can max­imise both ef­fi­ciency and er­gonom­ics. For ex­am­ple, we avoid the type nar­row­ing is­sues that arise when val­ues are ac­cessed by func­tion call, and when com­pil­ing in server-side ren­der­ing mode we can ditch the sig­nals al­to­gether, since on the server they’re noth­ing but over­head.

Signals un­lock fine-grained re­ac­tiv­ity, mean­ing that (for ex­am­ple) changes to a value in­side a large list need­n’t in­val­i­date all the other mem­bers of the list. As such, Svelte 5 is ri­donku­lously fast.

Runes are an ad­di­tive fea­ture, but they make a whole bunch of ex­ist­ing con­cepts ob­so­lete:

* the dif­fer­ence be­tween let at the top level of a com­po­nent and every­where else

* $:, with all its at­ten­dant quirks

* dif­fer­ent be­hav­iour be­tween and

* the store API, parts of which are gen­uinely quite com­pli­cated

* life­cy­cle func­tions (things like on­Mount can just be $effect func­tions)

For those of you who al­ready use Svelte, it’s new stuff to learn, al­beit hope­fully stuff that makes your Svelte apps eas­ier to build and main­tain. But new­com­ers won’t need to learn all those things — it’ll just be in a sec­tion of the docs ti­tled old stuff’.

This is just the be­gin­ning though. We have a long list of ideas for sub­se­quent re­leases that will make Svelte sim­pler and more ca­pa­ble.

You can’t use Svelte 5 in pro­duc­tion yet. We’re in the thick of it at the mo­ment and can’t tell you when it’ll be ready to use in your apps.

But we did­n’t want to leave you hang­ing. We’ve cre­ated a pre­view site with de­tailed ex­pla­na­tions of the new fea­tures and an in­ter­ac­tive play­ground. You can also visit the #svelte-5-runes chan­nel of the Svelte Discord to learn more. We’d love to have your feed­back!


Read the original on svelte.dev »

5 427 shares, 17 trendiness

mig4ng/ublock-origin-filters: My personal and very opinionated uBlock Origin filters

Use Git or check­out with SVN us­ing the web URL.

Work fast with our of­fi­cial CLI. Learn more about the CLI.

Please sign in

to use Codespaces.

If noth­ing hap­pens, down­load GitHub Desktop and try again.

If noth­ing hap­pens, down­load GitHub Desktop and try again.

If noth­ing hap­pens, down­load Xcode and try again.

Your code­space will open once ready.

There was a prob­lem prepar­ing your code­space, please try again.


Read the original on github.com »

6 414 shares, 3 trendiness

New name for the OpenTF project · Issue #296 · opentofu/opentofu

Have a ques­tion about this pro­ject? Sign up for a free GitHub ac­count to open an is­sue and con­tact its main­tain­ers and the com­mu­nity.

By click­ing Sign up for GitHub”, you agree to our terms of ser­vice and pri­vacy state­ment. We’ll oc­ca­sion­ally send you ac­count re­lated emails.

Already on GitHub? Sign in

to your ac­count


Read the original on github.com »

7 345 shares, 13 trendiness

78% MNIST accuracy using GZIP in under 10 lines of code.

Edit: brief ad­den­dum af­ter hit­ting the HN front­page; MNIST is a straight­for­ward dataset, and higher ac­cu­ra­cies are pos­si­ble with var­i­ous meth­ods. The nov­elty of this post is­n’t aim­ing for state-of-the-art re­sults, but show­cas­ing the po­ten­tial of us­ing com­pres­sion as a unique, model-free clas­si­fi­ca­tion tool. The code golf just adds a layer of com­plex­ity for fun.

We can solve’ MNIST up to ~78% ac­cu­racy with the fol­low­ing code-golfed ob­scu­rity:

If you just want to see the code sam­ple, here is a link to the Jupyter Notebook con­tain­ing the code to run this ex­per­i­ment.

Lets dive into why and how: yes­ter­day while in the one-hour train ride from Eindhoven to Rotterdam, I was in­spired by the post text gen­er­a­tion from data com­pres­sion and the (quite con­tro­ver­sial) pa­per on pa­ra­me­ter free text clas­si­fi­ca­tion to play around with us­ing com­pres­sion as an im­age clas­si­fi­ca­tion mech­a­nism. Previously, I worked on im­age com­pres­sion for com­puter vi­sion on the edge, so in­ter­ested in ap­ply­ing the tech­nique to the most sem­i­nal yet ba­sic dataset, I at­tempted to use GZIP + K-NN as a clas­si­fi­ca­tion mech­a­nism for the MNIST (handwritten dig­its) dataset.

Breaking down the tech­nique, it boils down to two com­po­nents: GZIP and NCD (Normalized Compression Distance) as a sim­i­lar­ity met­ric, and k-NN (k-Nearest Neighbors) for clas­si­fi­ca­tion. In this ap­proach, GZIP is es­sen­tially our tool which gives us a way to mea­sure the com­plex­ity or in­for­ma­tion con­tent of in­di­vid­ual data points. NCD pro­vides a nor­mal­ized mea­sure of how sim­i­lar two data points are, based on how much more (or less) ef­fort it takes to com­press them to­gether com­pared to com­press­ing them sep­a­rately.

For each test sam­ple, the al­go­rithm com­putes its NCD with every train­ing sam­ple (in our case, 100 train­ing sam­ples), sorts them, and se­lects the k small­est dis­tances. The ma­jor­ity class among these k=5 clos­est neigh­bors is then pre­dicted as the la­bel for the test sam­ple. As this is quite com­pu­ta­tion­ally ex­pen­sive, I only took a sub­set of the test im­ages to ar­rive at my ac­cu­racy mea­sure. Of course, it would be more cor­rect to use the full set, but I leave this an an ex­er­cise to the reader ;).

Here is a less ob­scured ver­sion of the al­go­rithm:

Note: af­ter writ­ing this post, I found this ar­ti­cle by Andreas Kirsch tak­ing a sim­i­lar ap­proach back in 2019. His ap­proach reaches around 35% ac­cu­racy.


Read the original on jakobs.dev »

8 345 shares, 46 trendiness

Terraria developer bashes Unity, donates $200k to open source alternatives

Welcome to the largest gam­ing com­mu­nity on Lemmy! Discussion for all kinds of games. Video games, table­top games, card games etc.

What Are You Playing?

Submissions have to be re­lated to games

More in­for­ma­tion about the com­mu­nity rules can be found here.


Read the original on lemm.ee »

9 342 shares, 11 trendiness

We have successfully completed our migration to RAM-only VPN infrastructure - Blog

We have suc­cess­fully com­pleted our mi­gra­tion to RAM-only VPN in­fra­struc­ture

Today we an­nounce that we have com­pletely re­moved all traces of disks be­ing used by our VPN in­fra­struc­ture!

In early 2022 we an­nounced the be­gin­ning of our mi­gra­tion to us­ing disk­less in­fra­struc­ture with our boot­loader known as stboot”.

Our VPN in­fra­struc­ture has since been au­dited with this con­fig­u­ra­tion twice (2023, 2022), and all fu­ture au­dits of our VPN servers will fo­cus solely on RAM-only de­ploy­ments.

All of our VPN servers con­tinue to use our cus­tom and ex­ten­sively slimmed down Linux ker­nel, where we fol­low the main­line branch of ker­nel de­vel­op­ment. This has al­lowed us to pull in the lat­est ver­sion so that we can stay up to date with new fea­tures and per­for­mance im­prove­ments, as well as tune and com­pletely re­move un­nec­es­sary bloat in the ker­nel.

The re­sult is that the op­er­at­ing sys­tem that we boot, prior to be­ing de­ployed weighs in at just over 200MB. When servers are re­booted or pro­vi­sioned for the first time, we can be safe in the knowl­edge that we get a freshly built ker­nel, no traces of any log files, and a fully patched OS.


Read the original on mullvad.net »

10 281 shares, 15 trendiness

The DuckDB IDE for Your Terminal.

The DuckDB IDE for Your Terminal.

The DuckDB IDE for Your Terminal.

Any shell, any ter­mi­nal, any ma­chine. Fish in tmux on Alpine over SSH? Sure. Windows cmd? Yep.

The fea­tures you’d ex­pect from an IDE, de­light­fully run­ning right in your ter­mi­nal.

* View ta­bles, columns, and their types across one or more at­tached data­bases.

* View up to 10k re­sults in an in­ter­ac­tive table. Multiple queries loaded into sep­a­rate tabs.

* Connect to any MotherDuck data­base in lo­cal or SaaS mode.

* Need more room? Press F10 to view the Editor or Results in full-screen mode.

* Export query re­sults and con­fig­ure the ex­port us­ing a help­ful UI.

Thousands are us­ing Harlequin. Join them with pipx in­stall har­le­quin.


Read the original on harlequin.sh »

To add this web app to your iOS home screen tap the share button and select "Add to the Home Screen".

10HN is also available as an iOS App

If you visit 10HN only rarely, check out the the best articles from the past week.

If you like 10HN please leave feedback and share

Visit pancik.com for more.