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.

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.

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.

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 {

sub­scribe,

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!

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.

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

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.

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.

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.

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.