dndn1

+1

Maybe they hope to kill new entrants for the enterprise market, including open source.

Surprisingly the GP didn't include price of the device as a reason, but the 30% Apple cut/likely uplift in price that developers need to charge to recuperate development costs - which are far more significant than developer hardware costs.

A non-Apple device without the moat would be better. GP also didn't ask for free apps.

Climate change is a problem.

Bret Victor did a good subdivision into sub-problems for a technologist here - which probably suits this audience:

http://worrydream.com/ClimateChange

The truth about cookie behaviour can be found, as it's a browser-driven feature (unlike fingerprinting). But at least some analysis of the cookies will be needed, as I think essential cookies under some definition/interpretation are permitted?

Now what exactly that means I'm not sure. But the first thing my cookie banner does when someone declines the banner is.... create a cookie. But I guess we can argue that's essential for the user experience - to keep the banner out of the way on follow-up page views. Not a lawyer or privacy expert though.

Edit: above is behaviour I found with at least 2 cookie banners. I'm interested in suggestions if this isn't standard!

I develop calculang, a language for calculations. It converts concise formulae into Javascript.

Since calculation formulae are usually inherently pure, a `--memo` flag to the compiler memoizes the lot.

Many of my models are written in this recursive style and only work because of memoization. Sometimes other tricks are needed e.g. careful ordering of the calls, so that the memo is available before the stack breaks.

My first calculang example is a bouncing ball: the position at t depends on speed and the position at previous t. With loops we'll usually discover the same thing, but it can be so much harder to follow.

First-class memoization to proliferate this style is a really neat thing.

[0] https://github.com/calculang/calculang

[1] bouncing ball code: https://github.com/declann/calculang-miscellaneous-models/bl...

[2] bouncing ball initial post: https://observablehq.com/@declann/calculang-bouncing-ball?co...

[3] if you can tolerate my slow-load WIP devtools and are on a Desktop, this is better, with buttons to navigate through the model development (only some of which are working now!): https://models-on-a-plane.pages.dev/stories/bounce/

BigCode seems to acknowledge this problem and provide a search tool for dataset used to train their StarCoder model.

https://huggingface.co/spaces/bigcode/search

My instinct about numbers (i.e. incl. statistics) is that they should be reproducible: on-demand, with results and workings easily subjected to interrogation.

In reality in many fields - my experience is in finance, but also in science - calculations are scattered across different languages and systems. This adds friction to any process about reproducing, understanding, analysing numbers.

This is some motivation for calculang, a language for calculations I develop. https://github.com/calculang/calculang

For the HN crew it's an under-development(!) functional language with properties to permit flexible designs that can scale. It's for numbers and if you share the model alongside your numbers people can check them according to the model and see the workings.

It goes well with visual number [dev/person]tools that I will release one of soon, and in the future watch for a browser extension for the workings behind numbers you are reading.

Important, it won't address the raw data part of the problem, but where numbers following from that are concerned, it might get closer to that instinct.

If it integrates so freely it should be a non-event when you, your CPA, and individual clients exercise autonomy over accounting software choices.

I don't think the FOSS vision in this space is to compel one new option on everyone that isn't an option. I can only imagine it's quite the opposite.

MITM will see everything, but this should be the case with headers as well as GET params, passwords/tokens/data etc.

A stackoverflow answer on this:

https://stackoverflow.com/a/499594

I don't think proxy servers or sniffers see GET data - it's encrypted, assuming HTTPS of course. Server logs might be an issue. Browser logs and accidentally sharing is definitely a bigger issue. Less of a concern if API is only used behind the scenes by apps though.

Disclaimer: I'm not an auth expert!

+1 for more llms and local llms

I look at these tools to see how they communicate these data processing/security details to their users.

There appears to be a lot of apathy/total disregard to giving users any clear clue.

It might not matter to me or this audience - we probably know the direction our data is heading - but it matters to less techie people, to ordinary employees and to civil servants and government people at the bottom and the top, who have no notion where their data is processed and who they are trusting with it.

(Stating because you linked to them) OpenAI interests are quite distinct from helping poor people, +I think on this day quite different regarding democratising the technology for poor people.

What I read sounds like the project owner can clearly articulate the projects purpose (a point about free speech and big tech v lightness and about enabling). And the proposed contributions are reasonably contrary to them as he sees it.

Experience, time... I think the response in this case was perfectly reasonable so I don't know how to remark on this.

Hosting the code (someplace) and discussing issues may be separate good suggestions, all in the context of the projects purpose.

If your work isn't professional, high-stakes stuff for a client, perhaps you can take some sting out of the hard finishing part by heavily and prominently disclaiming your work, and writing down the things you haven't done.

Is the purpose really to release polished products? Or to learn and try something new and share it?

By stating the purpose you can make those disclaimers more relatable and reasonable and set your users expectations.

Also know that starting, exploring and learning are brilliant useful skills by themselves.

Finishing is another skill, and if you want to be good at it I think it's useful if you can take some pressure out of it, start with low expectations and then with practice you get better, like all things.

Also, you can't expect yourself to finish all things because its time consuming like all the steps.

Example and shameful plug: models I release here that are plastered with disclaimers, but this is what lets me share something and move on.

https://observablehq.com/@declann/pension-calculator-ireland...

The number appears to me as ~20 x 10^22 J

I tried to replicate your maths using 1Bn W for a power plant and I get ~6.3M years. Did you use a different W?

I chose 1Bn from reading https://www.energy.gov/ne/articles/infographic-how-much-powe...

I'm glad your comment triggered me to do this exercise!

Boggling numbers all the same, and this is only the top half-mile of ocean

Chart for Ocean Heat Content under trends.

Source is @ https://www.climate.gov/news-features/understanding-climate/...

How do they pick a 0 elevation?

How is this the case whenever apparently Credit Suisse investors are not made to pay Credit Suisse debts?

E.g. Saudi National Bank, who announced no more cash to CS

I'm developing calculang, a language for calculations: https://github.com/calculang/calculang

I've made some examples here: https://observablehq.com/collection/@declann/calculang

Some tooling work for visualizations and for showing the workings will be released in the next weeks.

There are no positive money flows; I've spent many years experimenting, developing, and now 1 year after a public release the twitter page where I make announcements has 24 followers: https://twitter.com/calculang

I'm a modelling consultant - I work with numbers, I think they should be simple, but they are disjointed across systems and entities and programming languages and spreadsheets. The friction accumulates everywhere: to get a simple result, to follow the workings, to do any analysis, to share one or the other. calculang can consolidate calculations/numbers and is also a tool for transparency, understanding, and education.

I haven't done introductory documentation beyond the technical README which I think is vague (feedback accepted), and I plan to do a Show HN introduction to the community when I fix key snags: documentation among them.

For me the project is rewarding on many levels. In my client work - mostly financial sector - there is usually limited scope to take a really fresh perspective. There are no restraints here, it is useful to broaden my interests and thoughts in modelling, visualization, and wider more-grounded things like education and transparency, and I also get to be enthusiastic about a project that's tangible and simple at its core. In other words, plenty of positive flows besides the direct $ number :)

I built a quick/wip payroll validator [0] that can read state (i.e. payroll details) from the URL.

The purpose in this case was to generate a QR code, the idea is this can be included in physical payslips. Then the numbers behind the calculations (tax deductions) can be validated, broken down, and understood. I'm developing more tools to these ends, via my overarching project calculang, a language for calculations [1].

I also have a loan/repayment validator [2] but haven't added this QR code feature yet.

Bank letters e.g. "Interest rates are rising and now we want 100e more per month, every month" could use a QR code to an independent validator or to see the workings behind the 100 calculation.

Not using this in the real world now and there are security considerations to keep in mind, but reading state from a URL facilitates the usecase: QR codes that link physical numbers to their calculation and model.

Implementation of payroll calculator is an Observable notebook and thankfully it neatly supports all my strict requirements as demo of this.

[0] https://observablehq.com/@declann/payroll-playground-ireland...

+Feature tweet: https://twitter.com/calculang/status/1608183731533107206

[1] https://github.com/calculang/calculang

[2] https://observablehq.com/@declann/loan-validator-dev

For 8yo, maybe you can consider bringing her through Hedy:

https://hedy.org/

It's gradual (starts easy but limited, then with progress through levels gets more precise and powerful), and I read that it gets to full blown Python programming.

Theres an excellent talk on the approach by the author:

https://m.youtube.com/watch?v=fmF7HpU_-9k

Edit: +Hedy is designed with kids in mind, as opposed to adults, which I believe future coder and others are more targeted to.

Thats 1 option, but I think there is more to explore than that.

E.g. to look at canvas implementation it appears CF delivers a Chromium render to canvas. Maybe what helps here is standardisation. That render wasn't sufficient during the browser wars of ole, but isn't a point of contention now because of standardisation.

CF are doing a remote canvas/input. Why doesn't remote audio/input work for screenreader case?