Threads for Student

  1. 5

    TLDR for the article: author uses views and rewrite rules to implement soft deletion without altering the application code.

    This was pretty interesting. Triggers have significant overhead, although for deletes I wouldn’t expect that to matter much (simply because you’re normally operating on a small number of rows).

    For a complete solution (nb @vosper), you would also want partial indexes of the deleted and undeleted rows; and you’d want to clear the tombstones out of the way, either by periodically hard deleting (maybe to another table) or by clustering the table with an index with the deleted column as the first key.

    Tbh I don’t have any intuition as to why this is better than a trigger that inserts a copy of the row to another table, which avoids the need for the indexes and tombstone management I mention in the previous paragraph.

    1. 1

      This is well worth doing if you already use use-package. In combination with with-native-comp (a patch) my startup is now about 1s.

      1. 1

        Good write-up. I’ll just add two things that made a big difference with my own config:

        • Set file-name-handler-alist to nil while running the init file. Otherwise it will match each Elisp file against this list when they are opened to be evaluated.
        • (If applicable) upgrade from Fedora 35 to 36. Somehow my Emacs startup time (with exact same home-made build of Emacs 28.1) was reduced from ca 0.8 seconds to ca 0.2 seconds after my OS upgrade. I don’t know why, but I guess improvements in some dynamically loaded library. (Happy to hear if anyone has theories.)
        1. 1

          Great tip on the handlers.

        1. 2

          Do not embed your business logic in the database.

          1. 19

            Only a Sith deals in absolutes. (:

            What about tools like PostgREST that allow you to embed all the business logic in the database?

            1. 9

              Why not?

              1. 8

                There are conflicting opinions on this.

                Some people think they should push everything into the DB and the UI basically equates to pretty eye candy and user experience(UX).

                Some people prefer a middle ground, and some people think all the business logic should live outside the DB.

                I personally don’t think there is any one right answer. I think it depends on where the API boundary is, which mostly depends on the application.

                If you have a need/desire to give end users DB access, then you almost certainly want a lot(if not all) business logic in the DB.

                If you treat the DB as nothing more than a convenient place to store some data, then putting business logic there is stupid.

                Most databases can support any/all of these options.

                1. 5

                  zie’s answer is good. Another perspective: single responsibility for microservices.

                  You don’t reimplement logic in multiple apps writing to the same store. So either you have a microservice dedicated to providing the API needed while remaining the single-source-of-truth, or you have business logic in the RDBMS so that the RDBMS effectively embeds that microservice.

                  And then it’s a question of available skillsets of your staff, and how many people are good at debugging stored procedures vs issuing distributed traces, etc.

                  It’s all trade-offs.

                  1. 5

                    so that the RDBMS effectively embeds that microservice

                    That’s an awesome way to describe the approach that I haven’t heard before. It sounds like it could also be used to make some db engineers twitch when I refer to their stored procedures repo as a microservice. Great! :-)

                    1. 4

                      With a custom wire RPC format no less.

                    2. 1

                      I agree with this as a valid perspective.

                  2. 4

                    The example given wasn’t really business logic, right? Just an abstraction over normalization?

                    1. 3

                      It’s not business logic, it’s pretty much like a database view, which certainly belongs into a database. I think abstractions for data belong close to the data. That also means that you can change, replace, the thing that interacts with the data, the actual business logic.

                      One can be cut by this easily, when designing database schemas to close to a framework, ORM, etc. only for things to change and having a horrible migration path, potentially having to replicate very unidiomatic behavior.

                      So I’d argue, data and data representation doesn’t belong in your business logic.

                      Or at least for keeping logic and data separate, which you don’t do if you essentially build parts of the schema or views in your business logic.

                      1. 2

                        …unless you can put all the logic in there. …or, you need to do selects on that data. …or, other business units have views into your schema …or, you have compliance requirements to do so

                        etc

                      1. 2

                        My experience with uuids vs integers in Postgres is that for operations involving multiple rows (joins, selecting sets), bigints and ints end up being significantly faster (ie the queries take less time) even with indexing. I assume all the usual factors come into play (index size, number of processor cycles per comparison). Of course, you can have more than one unique key for different purposes.

                        1. 5

                          Ok so go isn’t rust, scala, or haskell. Pretty much all these criticisms could be leveled at Python or ruby (at least without their optional type checkers).

                          I don’t think it’s coincidental- golang is a c flavored language that targets much the same programmer use cases as Python and ruby. Lots of programming has a lot of io, a lot of iteration over requirements that are completely ill defined, and needs to be easy to read. Yes this potentially lets bugs hide and requires that you run the code to achieve reasonable certainty that it works, but there’s a reason we’re not all programming in agda.

                          1. 4

                            I think your comment is an interesting intermediate phase which precedes the point in the discussion where Go is directly compared to Rust alone.

                            In the first part of the article, we are linked to two case studies for Go’s unsuitability as a low-level systems language. In the first case study, a standard library structure is mutable and large. In the second case study, the standard linker and GC have large footprints. Scala and Haskell are no better than Python and Ruby at managing runtime footprints or structure size, because none of them are low-level systems languages. This leaves Rust as the lone contender in the discussion.

                            1. 5

                              I don’t really believe that the majority of Go programs have much overlap with the majority of Rust programs. Sure there are cases where both Go and Rust are legitimate candidates for the same software, but I think Go is much more often competing with Java and Python than Rust, and Rust is more often competing with C++/C than Go.

                              1. 2

                                Go was intended to replace C++. This is a well-cited motivation; Wikipedia says, “[Go’s] designers were primarily motivated by their shared dislike of C++.” I was at Google when Go was ascendant, and it was internally pitched as a replacement for C++, which was (and still is) one of the main pillars of Google code.

                                It was a curious turn of events when many Python and Java programmers switched to Go; it had not been anticipated. Go lacked the powerful dependency-injection tooling available to Java programmers, and also the flexible metaprogramming of Python; it wasn’t intended to be a compelling alternative for them.

                                1. 2

                                  In fairness, go is a good replacement for the use case of “I want C++ because it’s compiled and I’m not especially interested in safety or latency”.

                          1. 4

                            No very explicit statement of why one would want this, but it seems like the implication is you want to embed Python in your swift and you don’t want to embed cpython. Given the limitations and lack of benchmarks it seems like it’s squarely aimed at the extension language usecase.

                            https://github.com/LiarPrincess/Violet

                            1. 4

                              Or maybe the justification is “RWIIS all the things!” which I have no doubt exists by corollary with RWIIR.

                              Or it’s just not finished yet. Note the lack of GC, or of any way to free memory without destroying the Python context … that’s kind of a big caveat for most real world use.

                              Interpreters and runtimes are cool. It looks like they have some interesting code in there, like their BigNum implementation and a DSL for generating ASTs.

                            1. 3

                              It sounds like golang is not good for whatever it’s being used for, but even in the guy’s 4 blog posts there isn’t a ton of detail.

                              Golang is good (perhaps not great) for things where you’re mostly doing io on unixoid platforms and there are no really complicated algorithms. It also discourages cleverness by verbosity (unlike Java encouraging both cleverness and enforcing verbosity). Concurrency is less painful than most other languages.

                              Not every programming language is great for every use case.

                              1. 2

                                He said on Twitter he was professionally using it for networked services on *Nix.

                              1. 8

                                I remember my first contact with SELinux about 2007 when I wanted to use XEN virtualization on Fedora.

                                I put ISO images and systems ‘disks’ at my /home/vermaden dir - then specified path to these file at XEN configs and wanted to start the machine.

                                I could not. I only got Permission Denied errors. Nothing more. I checked all the chmod(8)/chown(8) permissions but still no luck.

                                After loosing half a day and searching for the solution on the net I find out that the default SELinux policy requires that all of these files need to be under /var/lib/xen/images path … and SELinux error Permission Denied tells NOTHING about this. Its just shit. Omit like all other shitty ‘technologies’.

                                1. 14

                                  The system call that opens the files are unaware of why access was denied. It doesn’t say it’s because of permissions or MAC. journald has made this a bit easier by displaying the program error log next to the audit messages. However, even if you realize that it’s SELinux there’s still no easy path or documentation on how to properly resolve the problem.

                                  1. 14

                                    There’s a related problem, which is the inverse of your specific case and which has been the root cause of some Chrome vulnerabilities on Linux.

                                    • If you get the policy wrong by making it too restrictive (your case), debugging the root cause is hard.
                                    • If you get the policy wrong by making it too permissive, you don’t get error messages of any kind, you just get security vulnerabilities.

                                    The root cause of both of these is that the policy is completely decoupled from the application. SELinux is designed as a tool for system administrators to write policies that apply globally to software that they’re managing but it’s used as a tool for software to enforce defence-in-depth sandboxing policies. Capsicum is a much better fit for this (the Capsicum code for the Chrome sandbox was about a 10th of the SELinux code, failed closed, and was easier to debug) but the Linux version was never upstreamed.

                                    1. 11

                                      But as the article expresses, system administrators typically don’t feel in control of SELinux policies. I think this is an agency problem. The developers are most familiar with the needs and potential vulnerabilities of a program. The administrators are most aware of the requirements the users of the software have. But the policies are written by the distributor (Fedora/Red Hat), who is aware of neither.

                                      The usability of SELinux isn’t great either (and as a developer I much prefer a capabilities-based system), but I think that’s almost secondary to the way it is used in practice.

                                      1. 7

                                        And app documentation is generally completely missing about the environment the app is expected to run in, i.e. they say “linux” but never goes into more depth. Stuff like the default is to read from these directories and write to these, I require these ENV variables, etc.

                                        None of that is ever documented in any program I’ve ever found(that I remember). Shoot, just getting a list of ports a network app runs on for FW rules can be like pulling teeth sometimes.

                                        It’s super hard to write a reasonable SELinux policy without this information, so you run stuff like audit2allow and just hope for the best, and then randomly flip on extra permissions here and there until it seems to run, call it good and move along. To do it right you need to have developer experience and sysadmin experience and be willing to do deep dives for every installed instance.

                                        I’m a fan of Capsicum, and the pledge stuff that OpenBSD is doing, as at least the developers have a much better chance of getting it right @ runtime.

                                        1. 5

                                          Another thing developer-managed capabilities facilitate is dynamically dropping them at runtime. The administrator has disabled the admin interface? Drop network privileges. Did you finish reading your config file? The developer knows the process never needs to read another file again.

                                          On the other hand, these policies are not easy to audit. They sit embedded in the code, opaque to administrators and auditors. Knowing what they are requires you either trust the developer, or have access to the source code.

                                          SELinux is a good policy system for an ecosystem where there’s an adversarial relation between the people implementing the software, and the people who run it. I don’t think it’s a natural fit for most FLOSS operating systems.

                                        2. 3

                                          So to summarize, no-one likes selinux because it’s hard for everyone

                                      2. 5

                                        I only got Permission Denied errors. Nothing more.

                                        This is the typical “first contact” with SELinux. You might be super well versed in Linux/Unix security with years of experience in several distros, but if you’ve never used a system with SELinux (ie RedHat), this is what you’ll see and it’s absolutely maddening. None of your regular Linux skills and knowledge transfer to an SELinux-enabled Linux, and the errors make no sense. And to ask someone to spend weeks or months studying this crap that’s typically only used in the context of one distro? I don’t think so.

                                        1. 1

                                          try to put some libvirt virtual machine images outside of /var/lib/libvirt/images if you have apparmor enabled (for example on debian). Great fun ahead. I can understand that pain, not only related to SELinux :/

                                        1. 14

                                          This reads like a puff piece. It’s an interesting project but I wouldn’t say there was a real takeaway except that you have YC funding now.

                                          1. 11

                                            Ouch; this is very unconstructive criticism.

                                            1. 4

                                              I liked the article as an experience report - you can build something Erlang-ish in Rust on wasm and end up at least convincing yourself (and YC?) that it works. I agree that the article doesn’t have a strong central thesis, but I found it interesting.

                                            2. 11

                                              Sadly I believe you’re correct, especially given the post history here.

                                              For folks that quibble with this dismissal as a “puff piece”: for me at least if this post had any code at all showing how the APIs changed, how this mirrored GenServers or other BEAM idioms, how various approaches like the mentioned channels approach changed the shape of could, or anything like that I wouldn’t be so dismissive. Alas, it seems like a growth-hacking attempt with lots of buzzwords (I mean christ, look at the tags here).

                                              Marketing spam and bad actors still exist folks.

                                              1. 2

                                                Hi friendlysock, I do mention in the post “Check out the release notes for code examples”. Here is a direct link to them: https://github.com/lunatic-solutions/rust-lib/releases/tag/v0.9.0

                                                1. 6

                                                  From (successful) personal experience: you can get away with promoting your stuff if you offer people something of real value in exchange for taking their time & attention. Nobody cares what’s in your GitHub: make content that is on the page you are posting that is worth reading.

                                                  1. 5

                                                    Friend, your only contributions to this site have been entirely self-promotion for your Lunatic project. It’s a neat project, but you are breaking decorum and exhibiting poor manners by using us in a fashion indistinguishable from a growth hacker. Please stop.

                                                    1. 1

                                                      I don’t think it’s fair to call a blog that has 3 posts in 2 years “marketing spam”. This submission is currently #1, so it’s obviously of interest to the community. But with this backlash in the comments I’m definitely going to refrain from posting in the future.

                                                      1. 19

                                                        I don’t think it’s fair to call a blog that has 3 posts in 2 years “marketing spam”.

                                                        In one year, as I write this comment, you have:

                                                        • Submitted 3 stories, all self promotion.
                                                        • Made 5 comments, all on stories that you submitted, promoting your own project.

                                                        That is not engaging with this community, that is using the community for self promotion, which is actively contrary to the community norms, and has been the reason for a ban from the site in the past.

                                                        This submission is currently #1, so it’s obviously of interest to the community.

                                                        The rankings are based on the number of votes, comments, and clicks. At the moment, all of the comments in this article are either by you, or are complaining about the submission. This will elevate the post but not in a good way.

                                                        But with this backlash in the comments I’m definitely going to refrain from posting in the future.

                                                        I would say that you have two choices:

                                                        1. Stop posting altogether.
                                                        2. Engage with the community, comment on other stories, submit things that are not just your own work.

                                                        The general rule of thumb that I’ve seen advocated here is that posts of your own things should make up no more than 10% of your total contributions to the site. At the moment, for you, they are 100%. If they were under 50%, you’d probably see a lot fewer claims that you were abusing lobste.rs for self promotion.

                                                        1. 4

                                                          I don’t know how to resolve the problem that this is both an interesting project but only being posted by you, and that there’s a business wrapped around it, where you’re the ‘CEO’ - which just makes it a bit awkward when people are interested in the tech but opposed to ‘spam’.

                                                          I’m certainly interested in following the project, so I’d prefer that you keep posting!

                                                1. -1
                                                  1. 5

                                                    I’ve said it before and I’ll say it again: if you’re having any difficulty writing it in shell you should probably use Perl or something even more robust.

                                                    1. 15

                                                      Oh yeah, totally, the problem with the internet is not enough “autonomy”. As opposed to having our personas traded by data brokers, brains melted by social media, behaviors modified by targeted advertising and influencer culture.

                                                      These techno-libertarian 80s MIT hacker derivative “autonomy” and “freedom” arguments have been such a massive distraction from a material analysis of how power actually uses technology to exploit people for profit. The spectacle of the individual atomizes people and alienates them from common cause.

                                                      But if only we were to perfect our APIs and network protocols. Then we would not be exploited by internet companies. We would have autonomy 🙄

                                                      1. 3

                                                        I would like to subscribe to your newsletter

                                                        1. 1

                                                          I mean, we already have “autonomy” just layer your protocol on IP and away with you beasties!

                                                        1. 10

                                                          Even in userland I would like to at least know “can this panic” or “does this allocate” and things like that without having to recursively read docs/code.

                                                          1. 3

                                                            It seems like something that could be automated by analyzing a call graph.

                                                            1. 2

                                                              One difficulty with this is that Rust relies on optimization to remove panics, e.g.

                                                              let a = [1,2,3];
                                                              for i in 0..3 { a[i]; }
                                                              

                                                              Can’t panic, won’t have any panicking code in the release binary, but does have panicking index call in its call graph.

                                                              1. 1

                                                                I can’t think of a reason why this is bad, but it is remarkable to see a compiler that actually corrects code.

                                                            2. 1

                                                              I wonder if this could be enforced or checked at compile time.

                                                              1. 4

                                                                There are some truly awful hacks to do it as a library: https://docs.rs/no-panic/latest/no_panic/ I don’t think there’s any inherent reason it couldn’t be in the compiler, it’s just that it’s a language addition and no one has written an RFC for it.

                                                                1. 3

                                                                  It would be really nice.

                                                                  For example, there’s std::thread::spawn() → JoinHandle<T> which can panic, so instead you use .spawn() → Result<JoinHandle<T>> on a thread::Builder, like the docs suggest.

                                                                  The docs for that one say it can panic "if a thread name was set and it contained null bytes", but is that really the only condition? No, it can panic for other recoverable errors as well; the Result doesn’t capture all of them.

                                                                  So it gets hard quickly.

                                                                  1. 1

                                                                    Maybe there’s a flipside that’s easier. Crates do declare where they do (or to guarantee they never do it). Obviously this will be easier snd More reasons for special crates that will be (or have been) build with those use cases in mind.

                                                              1. 6

                                                                Fennel being loadable from Lua, and Lua being written in ANSI C makes an interesting combination for anyone wanting to write bootstrappable software in a functional style.

                                                                1. 4

                                                                  Aren’t many LISPs written in C?

                                                                  1. 9

                                                                    Indeed but Lua is insanely portable. They have taken great pains to depend only on what is guaranteed by C89: there are no endian dependencies, no assumptions about struct layout, etc.

                                                                    1. 5

                                                                      Yes but it’s unusual to have no dependencies beyond a C89 compiler and libc.

                                                                      1. 2

                                                                        I’m pretty sure Janst can be built with just a C compiler. And several of the numerous dialects of Scheme.

                                                                      2. 3

                                                                        Some, but most are written in Lisp, maybe or maybe not with a C core for runtime. Bootstrapping is occasionally a bit of a headache.

                                                                        1. 3

                                                                          Most LISPs are not what I’d consider Functional. They’d support it, sure, and functions are first class, but they don’t emphasize immutability and bottom-up-creation and side-effect limiting like what I think of with functional languages.

                                                                          1. 4

                                                                            Absolutely true. I’ve never understood why LISP gets associated with functional. The syntax seems like it would lead that direction, but in practise most LISPs are very low level.

                                                                            1. 2

                                                                              Back when lisps were new, the fact that it was even possible to do functional programming at all was considered unique and novel. Having access to lambda was considered a very advanced feature. Nowadays if your language doesn’t even have closures, no one will really take it seriously, so whatever association lisp-in-general has with FP should probably be thought of as historical.

                                                                              1. 3

                                                                                When lisps were new, they frequently lacked lexical closures. See the ‘upwards funarg problem’.

                                                                                1. 1

                                                                                  I may be a heretic here but I actually think lexical closures are bad, and a poor substitute for currying/partial application.

                                                                                  1. 4

                                                                                    You’ll hate Fennel then! Probably shouldn’t use it. Closures are more central to Fennel than any other language I know.

                                                                                    1. 1

                                                                                      More than other lisps?

                                                                                      1. 2

                                                                                        I haven’t used every lisp, but …

                                                                                        • much more than: Emacs Lisp, Common Lisp, Hy, LFE
                                                                                        • a fair bit more than: Clojure
                                                                                        • a little more than: Racket, Scheme (mostly due to the module system which is mostly closures)

                                                                                        Fennel has partial, but not currying, since it’s on a runtime where argument count for a function isn’t determinable.

                                                                                    2. 1

                                                                                      What is the difference between lexical closures and currying/partial application?

                                                                                      1. 2

                                                                                        With a lexical closure every term that is closed over now has to live as long as the execution of that closure, with no explicit annotation of anything about the sharing.

                                                                                        When a human reads the program they have to remember if this is a by-value or by-name binding.

                                                                                        If you want a type system that incorporates lifespans or ownership, then again you need some default rule to describe the relationship between outer and inner code, which the programmer has to remember and cannot alter.

                                                                                        By contrast, if all such sharing happens via a function call (which is to say with explicit parameter passing and type annotation) then the writing programmer can make explicit what the sharing regime is, and the reader can apply the same rules that apply when they read any other function call.

                                                                                        Obviously, you can do absolutely amazing things with lexical closures, but you can also do all those things with non-closing functions and partial application.

                                                                                        I guess I’m saying that explicit is better than implicit.

                                                                                        1. 2

                                                                                          When a human reads the program they have to remember if this is a by-value or by-name binding.

                                                                                          This is less an argument against closures and more an argument for making your language have consistent and sensible argument passing semantics. It’s not a problem in Fennel because the distinction between pass-by-value and pass-by-name is irrelevant.

                                                                                          If you want a type system that incorporates lifespans or ownership, then again you need some default rule to describe the relationship between outer and inner code, which the programmer has to remember and cannot alter.

                                                                                          Again, there are plenty of contexts where this is true, but none of this is the slightest bit relevant here.

                                                                                          1. 2

                                                                                            Thanks for the response, but this didn’t address the question I had.

                                                                                2. 1

                                                                                  Yeah my knowledge is somewhat stale but at least back in the day only the very core functions were in C and the majority of the image was LISP.

                                                                                  There was also a lot on top of that core that use a foreign function interface to layer in functions from C-land like UI libraries and the like.

                                                                                3. 3

                                                                                  Fennel & Lua seem like a great duo to be aware of. I’ve also recently learned about Fabrice Bellard’s QuickJS which is interesting for similar reasons as a simple & embeddable pure C implementation of ES2020.

                                                                                1. 2

                                                                                  I’m always curious why projects choose to create an entirely new Lisp dialect instead of a new implementation of an existing Lisp (like Common Lisp or Scheme).

                                                                                  Personally, I’d rather use a standardized language and be able to choose the best implementation for my needs. Especially in the Lisp world, where syntax isn’t a big deal because of macros - if I like something Fennel is doing, I can write macros to do it in Common Lisp. And there are a lot of existing Scheme and CL libraries, and a whole bunch of books and other documentation.

                                                                                  I can see why it’s practical for Lua users, but for people not already tied to that ecosystem, what’s the advantage over Common Lisp?

                                                                                  1. 6

                                                                                    I’m always curious why projects choose to create an entirely new Lisp dialect

                                                                                    There’s a page for this on the Fennel web site if you’re curious: https://fennel-lang.org/rationale

                                                                                    if I like something Fennel is doing, I can write macros to do it in Common Lisp.

                                                                                    This isn’t true in a meaningful way; a lot of the advantage of what Fennel provides is what it omits; by removing the ability to do certain things you end up with more predictable, obvious code and powerful guarantees. Simplicity cannot be added to an existing language by piling on macros.

                                                                                    I can see why it’s practical for Lua users, but for people not already tied to that ecosystem, what’s the advantage over Common Lisp?

                                                                                    For the past few years, there’s been a lisp game jam in the spring and autumn. Before Fennel came around it was mostly Schemers and CL programmers, but since Fennel has been introduced, most of the events have been won by Fennel games, and every time Fennel makes up the majority of the top 5 entries. https://itch.io/jam/spring-lisp-game-jam-2021/results

                                                                                    This is 100% due to the ecosystem; the CL programmers end up spending a lot of time building things from scratch which are readily available to Fennel programs. When it’s time to go rate the games, the Fennel versions are always easy to download without any manual hunting down of dependencies, (because these problems have already been solved by the developers of love2d and TIC-80) but it’s like 50/50 whether I can even get the CL ones to run at all on my machine.

                                                                                    You don’t have to be already tied to that ecosystem to see the advantage there.

                                                                                    1. 1

                                                                                      lot of the advantage of what Fennel provides is what it omits; by removing the ability to do certain things you end up with more predictable, obvious code and powerful guarantees

                                                                                      It is possible to embed complete languages with arbitrary semantics; see e.g. coalton.

                                                                                    2. 1

                                                                                      I’m p sure the answer is that it’s easy to get started implementing a lisp, and for a certain sort of person, fun.

                                                                                    1. 1

                                                                                      I think of singletons as a code smell. Why not just have two root objects?

                                                                                      1. 2

                                                                                        I tend to agree, and I’ve even heard it referred to instead as the “Highlander” anti-pattern (based on the Highlander sci-fi franchise with immortal warriors fighting each other and shouting “there can be only one!”). It’s weird to me to see how many people in this thread dismissed it as just Python not having good enough tooling for the good singletons of other languages…

                                                                                      1. 3

                                                                                        Lisp is 70 years old. Even if you don’t start the timer with John McCarthy’s first version, it’s clearly an idea with staying power.

                                                                                        @wizeman’s suggestion of ML is good for many of the same reasons - it’s already stood the test of time.

                                                                                        1. 8

                                                                                          Tl;dr quote is

                                                                                          Liu and Pass proved that if a certain version of Kolmogorov complexity is hard to compute, in a specific sense, then true one-way functions do exist, and there’s a clear-cut way to build one. Conversely, if this version of Kolmogorov complexity is easy to compute, then one-way functions cannot exist. “This problem, [which] came before people introduced one-way functions, actually turns out to fully characterize it,” Pass said.

                                                                                          1. 2

                                                                                            Ok whether or not it’s “magic”, is it hard to understand for the target audience?