laserbeam

I’d like to see a real shell script written in ion very early in the readme or manual. Something that wgets a tarbal, extracts some part if the filename, checks cpu usage, draws a simple progress bar to the terminal, checks a folder for old files, some script that implements prompt completions for some cli tool…

I really don’t care that a new shell is written in rust. I care to see examples of how it actually would be better than bash.

The fact that it’s written as a personal journey and not as advice suggests the author was on a journey to become more genuine/accepting of who they are. It does read as someone who tried to be manipulative at the start but graduated away from that towards the end of their journey.

You can gain a lot from the article and see it as both manipulative, or as insights for working through your own social anxieties. You could bring both attitudes to the article. And one of those is obviously healthier than the other.

Unfortunately, I require PDF outputs for some of my documentation. Right now this is possible via some plugins (I cannot remember which fork of a pdf export plugin worked, but at least one does) in Material for MkDocs. It’s not perfect, but it is good enough.

Should I expect a “good enough” pdf export experience in zensical at some point or now?

> What is the renewed interest?

We just don’t have good desktop GUI platforms anymore. Qt and GTK are massive beasts, Windows changes theirs every 4 years (and no one wants to be tied to a single platform anyway), we don’t want to deal with Electron, and writing your own GUI from scratch is hard.

Terminals just got good lately and it’s way easier to make something higher quality in them than as a GUI. It’s just too hard to make a good small desktop app.

It’s the same reason why it’s easier to make something look great with LEGO than if you want to mold clay. I’d also wager that devs today on average know more about good UX than devs did back in the 80s when clunky terminal apps used to be made.

My point is not that it’s bad UX or not, my point is the website is bad at selling me their product and could never convince me that it’s good.

This is a mobile OS, right?

I go to the homepage. Zero screenshots. I go to the User Experience page. Zero screenshots. I even go to Design Principles under the UX page. Zero screenshots.

Talking about mobile phone design is like dancing about architecture. Show the thing or bust.

Kind of is a bad idea. Even the author’s library is not using the latest zig IO features and is planning for big changes with 0.16. From the readme of the repo:

> Additionally, when Zig 0.16 is released with the std.Io interface, I will implement that as well, allowing you to use the entire standard library with this runtime.

Unrelated to this library, I plan to do lots of IO with Zig and will wait for 0.16. Your intuition may decide otherwise and that’s ok.

Yeah, overall it feels somewhat useful in a work context. Nothing transformative though.

It’s really hard to parse both the announcement (too much hyperbola) and the article (too technical), however as I understand it, this is what quantum computing should be good at. Not at making classical algorithms faster, but at simulating quantum physics experiments. This is a good direction and I find it more plausible than “we factored numbers faster”.

This SHOULD be the main application of the tech. It’s hard to tell if it is because authors can’t do science communication, they can apparently only do sales.

You really do need units in your tables. It is not very obvious you are talking about FPS in them… or is it milliseconds or microseconds. The only place a unit of measurement is actually mentioned (FPS) is the window title of a screenshot.

This, is gorgeous! I absolutely hate the PDF ecosystem, and how painful it is to get a reasonably simple tool to just do basic edits to files (adding/removing pages, combining multiple PDFs etc). I particularly hate how hard it is to find good swiss army knives for it, and how you always land on sketchy websites to do simple things to a file.

This looks dead simple to use! LOVE IT.

The one feature request I have is for adjusting margins (adding/removing fixed amount of space from every page, optionally adding/removing different amounts from odd numbered pages). Target audience: People who want to read PDFs on small ebook readers.

I love my e-ink tablet.

Regardless of manufacturer (remarkable, boox, supernote…), all e-paper tablets have one major performance problem: quickly scrolling through multiple pages of notes. No idea if the display is the limiting factor, or the cpu, but I’ve hit this issue on all tablets I’ve used. If you like riffling through pages in you paper notebook, you will hit the limit too. I know at least 2 people who stopped using their tablets over time because of this issue.

If this tech helps solve that problem, it’s more important to me than an eink monitor.

Edit: this is mainly important for notes, because sketches, scribbled diagrams and quick notes half-taken in meetings are not really searchable. PDFs and ebooks don’t have this problem.

Reminds me of dion systems. A few years ago a group of devs was working on a programming environment that feels very close to what DIANA is describing.

The project is dead enough that they no longer own the TLD for the company. As far as I know, the only remnants of the project are youtube recordings of demos held at conferences.

Zig is currently undergoing lots of breaking changes in the IO API and implementation. Any post about IO in zig should also mention the zig version used.

I see it’s 0.15.1 in the zon file, but that should also be part of the post somewhere.

It reads like the author has never written a test in their life. Yeah, HTTP (one of the examples) doesn’t rely in types, it relies in rolling your own input validation…

Type checking is simply built in testing for a subset of problems. At scale, the only thing you gain from dynamic typing is the need to write even more tests than usual.

I imagine it would be straightforward to support this for codebases which already define multiple allocators (game engines, programs written in zig, bunch of other examples I’m less familiar with). If you’re already in memory management land you already you already have multiple implementations of malloc and free. Adding more of them is trivial.

If you’re not in manual memory management land, then you probably don’t care about this optimization just like you barely think of stack vs heap. Maybe the compiler could guess something for you, but I wouldn’t be worrying about it in that problem space.

I love kagi’s approach to AI summaries. They are disabled by default, but if you add a question mark at the end of the query you get an AI summary. Perfect opt-in for when you actually want it.

As a Romanian who has been very involved in Olympiads as a kid, I can tell that most of this is accurate. I’ve also lived in Denmark at university for several years and can contrast educational systems from first hand experience.

The sorting the author describes absolutely DOES happen in Romania. Exactly as he describes it, “getting into a good school” is incredibly important for students and parents here.

I’d also like to add the high school curriculum is very dense. The kind of math we did in 10th grade (there are 12 grades in Romania) was math people were only introduced to in their first year of university in Denmark.

There’re also a significant amount of optional after-school programs for contests, and I’ve only encountered students from good schools in them (as far as I can remember).

Yes, Romania is much better at filtering and at training people who are predisposed to intelectual work from a young age. Yes, Romania is bad at educating the masses.

However, I disagree with his conclusion and value judgement. I’d much rather see Romania adapt a system which educates everyone, rather than the world be better at filtering.

Geopolitical reasons for making your own OS are actually reasonable and understandable. Not saying they are good, because I would much prefer a planet where we collaborate on these things… but they’re not dumb. They make sense in a similar way the space race made sense.

I… will not update my zig side projects to 0.15.x. I can see why Andrew wanted to release this, and I can appreciate getting the new Io in people’s hands… but it’s merely a few weeks after merging massive amounts of breaking changes on readers and writers.

For those working on the standard library, it’s a great thing. For one like me who casually uses zig, it feels like waiting for 0.16.0 for most of the IO dust to settle is the right thing to do.

Every single dj software is super crammed and has no empty space in it. This is true because djs cannot switch views while performing. There’s a lot of info which must be visible at all times on 1 single page. Regardless of UI framework or target device, it will continue to be like that because the target audience needs the interface to be dense.

Oh yeah, I can only actually use them via private browsing (or nuking cookies, of course)

> There has yet to be a usecase for distributed ledger that isn't solved better by a centralised ledger

As I understand it, many countries in the European Union use distributed ledgers for elections. Essentially it lets you cross reference votes and store that database across servers in multiple countries. It also prevents post-election data tampering by the state holding the election.

My understanding is this this system is not an open to every random Joe who wants to have a server (like bitcoin is). I think you still need to be a state actor to be part of the distributed database (so it's not a zero trust environment).

(Unfortunately, I don't have any good links to back this claim up)

This short article is not about TODOs, it’s about good comments, in general. Any comment that gives you context about edge cases, about why some decision was made, about why other approaches went wrong is great!

I would argue TODO means “intent to implement”, and they should be regularly converted into either tasks, documentation or just standard comments without a special keyword.

As I understand it, you only need to allocate locals in other languages for stackless coroutines because every return statement is a yield point. I think zig is trying a different approach where they can’t get away with that assumption.

Keep in mind that you can’t really express half the concepts in lamport’s papers in most languages. You don’t really talk about total and partial clock ordering when starting a thread. You only really do it in TLA+ when designing a protocol.

That being said, I agree we don’t need a new term to express “Zig has a function in the async API that throws a compilation error when you run in a non-concurrent execution. Zig let’s you say that.” It’s fine to so that without proposing new theory.

Mutexes are part of the Io interface in zig. So is sleep, select, network calls, file io, cancellation…

I hope this is not a bad answer as I tried to understand what stackless coroutines even are for the past week.

1. Zig plans to annotate the maximum possible stack size of a function call https://github.com/ziglang/zig/issues/23367 . As people say, this would give the compiler enough information to implemented stackless coroutines. I do not understand well enough why that’s the case.

2. Allegedly, this is only possible because zig uses a single compilation unit. You are very rarely dealing with modules that are compiled independently. If a function in zig is not called, it’s not compiled. I can see how this helps with point 1.

3. Across FFI boundaries this is a problem in every language. In theory you can always do dumb things after calling into a shared library. A random C lib can always spawn threads and do things the caller isn’t expecting. You need unsafe blocks in rust for the same reason.

4. In theory, zig controls the C std library when compiling C code. In some cases, if there’s only one Io implementation used for example, zig could replace functions in the c std library to use that io vtable instead.

Regardless, I kinda wish kristoff/andrew went over what stackless coroutines are (for dummies) in an article at some point. I am unsure people are talking about the same thing when mentioning that term. I am happy to wait for that article until zig tries to implement that using the new async model.

The article should include a very obvious way for someone to test if they are affected. How does one verify (in an in a VERY clear and straightforward way) if some arbitrary system will run into this issue in September?

Yielding in this context means to a different “thread” in your context, not the OS. If you want to express “this is a point where the program can do something else” it is a yield. If you block and can’t switch to something else… it is not.

So if you’re using an API like mmap like that you should think of it as IO (I don’t think you can, but am not sure).