Joe Nelson (begriffs)

Such a great collection! I like https://begriffs.com Does anyone know any tool that will mass bookmark links on a page?

I put together a list of the best linear algebra books, classified by type. Proskuryakov's practice book is one of them. Here's the full list: https://begriffs.com/posts/2016-07-24-best-linear-algebra-books.html

It's been amazing following all the progress so far. I'm a proud $5/mo sponsor and look forward to writing something in Zig soon! Are there any concurrency constructs provided by the language yet? I'm just starting to learn how to do concurrency in lower-level langauges (with mutexes and spinlocks and stuff). I'm coming from the world of Python where my experience with concurrent state is limited to simple row-level locks and `with transaction.atomic():`. An equivalent article to this would be awesome for Zig: https://begriffs.com/posts/2020-03-23-concurrent-programming.html Edit: I just found this announcement for async function support: https://ziglang.org/download/0.5.0/release-notes.html#Async-Functions

Re-orderable items are best represented using a rational. There is a great blog post on the different approaches and trade-offs of user-orderable items[0]. [0] https://begriffs.com/posts/2018-03-20-user-defined-order.html

> After doing that book I wanted to see what other books were out there, which ones were the good ones, and sort of classify them. I came up with this list: https://begriffs.com/posts/2016-07-24-best-linear-algebra-books.html Ironically you put "Jänich, K. (1994). Linear algebra. New York: Springer-Verlag." into the "Theoretical" section: In Germany this book (its German original) is not that well-regarded, since it is considered as far to shallow. Much better (and more hard to read) German textbooks are Gerd Fischer - Lineare Algebra: Eine Einführung für Studienanfänger (Linear Algebra: An Introduction for freshmen) Siegfried Bosch - Lineare Algebra (and its companion book: Siegfried Bosch - Algebra)

If you are interested in different ways to write/implement regular expression this talk is worth the watch: https://begriffs.com/posts/2016-06-27-fast-haskell-regexes.html

A good faith look at V is that it's very much a work-in-progress, and that at times the documentation is "aspirational" rather than "factual". I'm reminded by an remark from Bill Joy in an old interview talking about writing vi: "I wrote manual pages for all the great features we were going to do but never implemented".[1] We've all done that, right? I certainly have, including in public projects. There's a lot to be said about the wisdom of publishing material like this, and it's fine to object. But phrasings like "they were able to lie in every sentence" do not sit well with me, especially since the bit that follows doesn't actually disprove the claims all that well. It's assuming the worst possible motivation (intentional deception) rather than the much more likely motivation (small team, tad too much enthusiasm, and perhaps at times, inexperience). I'm not entirely trusting the objectivity of an author who describes these sort of things as "lies". Even worse are things like: > He lies that coroutines work with IO. I’ll clarify that by working, I personally mean context switching when necessary, and not the fact that the program does not crash. So the functionality is correct, but not in a way the author would like it to, therefore it's a lie to claim it works. Eh? It's fine to criticize that the implementation isn't any good, of course, but employing such narrow definition of "works" and then calling someone a "liar" over it seems rather, eh, much. In short: not a…

PostgreSQL supports deferring constraints. https://begriffs.com/posts/2017-08-27-deferrable-sql-constraints.html

This is an interesting read on validation in postgres: https://begriffs.com/posts/2017-10-21-sql-domain-integrity.html

How do you easely piece together a (poerfull) rest api just by having the definitions of the tables in the database? Very very old videos but you can get the core idea https://begriffs.com/posts/2014-12-30-intro-to-postgrest.html https://begriffs.com/posts/2016-03-20-postgrest-tour.html

Most of that is abstracted away by "use what your library uses". I can't remember if I ever ran into an issue with Java because it used UTF-16. If you look at the example code of the OP link where it reads a line from a file, you only see UTF-16 mentioned in a comment. At a first glance, you only see a UChar* being filled. https://begriffs.com/posts/2019-05-23-unicode-icu.html#reading-lines-i…

Good addition! Here are some more: https://ferd.ca https://blog.filippo.io https://lethain.com http://movingpackets.net https://www.integralist.co.uk https://peter.bourgon.org/blog https://engineering.linkedin.com/blog https://begriffs.com https://mijailovic.net http://tatiyants.com http://blog.pentestbegins.com (seems down right now?) https://kalzumeus.com/archive http://blog.stephenwolfram.com https://paragonie.com/blog https://www.filfre.net https://brandur.org/articles http://archagon.net https://eklitzke.org I guess I could go on forever…

This post discusses using UUIDs as primary keys (but never exposing them), and an additional integer key on each table as the public facing ID. https://begriffs.com/posts/2018-01-01-sql-keys-in-depth.html HN discussion: https://news.ycombinator.com/item?id=16050047

Here is a tutorial on creating a static site with Hakyll and Github: https://begriffs.com/posts/2014-08-12-create-static-site-with-hakyll-g… EDIT: Tutorials about Hakyll: https://jaspervdj.be/hakyll/tutorials.html

Cont stands for Continuation. A continuation basically represents a 'suspended' computation with an intermediate result of type 'a' and final result of type 'r' type Cont r a = (a -> r) -> r Cont is a type constructor that takes two type arguments, r and a. This means that Cont r a can always be substituted by (a -> r) -> r. For example, Cont String Int is equivalent to (Int -> String) -> String (a -> r) is the type of a function from a to r. For example, Int -> Bool is the type of a function from Int to Bool. (a -> r) -> r is the type of a function that takes a function from (a -> r) as its argument and returns an r. So Cont String Int takes a function from Int to String as its argument and finally returns a String. http://www.haskellforall.com/2012/12/the-continuation-monad.html https://begriffs.com/posts/2015-06-03-haskell-continuations.html

An Advanced Introduction to GnuPG by Neal H. Walfield https://begriffs.com/posts/2016-11-05-advanced-intro-gnupg.html

I'm a big fan of taking advantage of laziness and think it's drastically underrated. It's incredibly expressive and it's what really makes Haskell more than just an ML variant. I gave a slightly rough talk about "Thinking with Laziness"[1] which tries to capture how expressive it can be. I'm a big fan and sad that so many people are willing to categorically dismiss it as a wart in Haskell. [1]: https://begriffs.com/posts/2015-06-17-thinking-with-laziness.html

You might be interested in looking at Gabriel Gonzalez' Morte ( http://begriffs.com/posts/2015-10-16-internet-of-code.html ), which started off as a supercompiler project, but seems to be moving somewhat in that direction.

react-haskell enables that http://begriffs.com/posts/2015-01-12-reactjs-in-haskell.html

Sure... Stackage: curated sets of packages that are known to work together. LTS Haskell: Stackage + pinning to a GHC version + seperating non-breaking upgrades (minor LTS version increases) from breaking ones (major increases). SSL downloading. Stack: also downloading/building of GHC if it does not exists, understands mega-repo's (many packages in one git repo), eases working with shared local pools of packages, eases working with dependencies that are not in Stackage/LTS, and more that I probably forget. A more detailed explanation of the merits of Stack can be found in this video: http://begriffs.com/posts/2015-06-22-haskell-stack-build-tool.html

Just today I read about postgrest[1], REST-like API for postgresql. While it is not REST by what this cookbook says (it uses JSON), it provides very different view at how API should work.[2] Postgrest versions the API using HTTP accept header. It provides "pagination" not using XML attributes, but using HTTP range headers, as the standard allows to specify partial content in items, not just in bytes. The author also suggest that deeply nested URLs are a bad idea, because most data (like relational data) is actually flat. It might provide interesting "second opinion" to what this cookbook says. It doesn't say anything about transactions, [1]: https://github.com/begriffs/postgrest [2]: http://begriffs.com/posts/2014-12-30-intro-to-postgrest.html

> But then still there is no oracle to predict whether user-supplied [RestrictedPython] code never halts; so, without resource quotas from VMs or Containers, there is unmitigated risk of resource exhaustion from user-supplied and developer-signed code This is actually something I was interested in a while ago, but in Scheme. For example GNU Guile has such a facility built in [0], though with a caveat that if you're not careful what you expose you could still make yourself vulnerable to DoS attack (the memory exhaustion kind). But if you don't expose any facility that allows the untrusted user to make large allocations at a time (in a single call) you should be fine (fingers crossed). I don't see a reason why the same mechanics couldn't be implemented in Python. [0] https://www.gnu.org/software/guile/manual/html_node/Sandboxed-Evaluati… Edit: in some sense this restricted python stuff also reminds me of Safe Haskell (extension) [1], which came out a bit ahead of it's time and by this point almost forgotten about. Might become relevant again in the future. [1] https://begriffs.com/posts/2015-05-24-safe-haskell.html - better overview than the wiki page

I get that you're just trying to get your software out there, but your modern features that email doesn't support are just wrong. >shared history Not if you have a mailing list, and then going off the record is as easy as removing the mailing list from the CC field. >markdown formatting This is an implementation failure, not really a fundamental problem with email. There is no reason that email clients don't support markdown, except that nobody has ever wanted it. There was someone who made a utility to switch markdown to regular MIME email, but just as a proof of concept. It works. >Image previews I assume what you mean by this is an inline thumbnail that expands when you click on it? Again, there's nothing about email that prevents it, it's just the way email clients are. That could be fixed >emoji reactions Okay, that's fair, there's no way to do this in email, short of sending a single emoji back. On the other hand, I think everyone would agree that this is more of a nice to have feature, than a necessary one, and one that really only makes sense in the world of quick, back and forth chat programs. [1] https://begriffs.com/posts/2020-07-16-generating-mime-email.html

> Second, the Serpent language is untyped. It allows any operation to be performed on any data. Every value is a 256-bit sequence which can be used as an address, a contract, an integer, or an array. I normally dislike people who criticize startups for not being perfect from day one and understand it takes iterations and a wide audience to get things right. But this isn't a normal startup and security was an obvious big piece of the puzzle from day one. Their reputation and developer adoption will depend on it. Why doesn't the primary Ethereum language have types? This is basic stuff if you're trying to reduce bugs from the outset. From my understanding they wanted the language to be as accessible as JS... but even JS developers are all converging on types via TypeScript, Flow, and Babel plugins like babel-typecheck. It's basically an accepted requirement of "5th-gen languages"... let alone for language-based interfaces to security focused systems. Immutability seems like another obvious choice here for catching errors at compile time and forcing careful design considerations. Also the language should have a (typed) Quickcheck implementation that hammers each function with random data to check for breakage... and it should be documented as standard practice. https://begriffs.com/posts/2017-01-14-design-use-quickcheck.html The fact Tevos is built with OCaml and is focused on code safety/verification gives me hope there is some sanity in the cryptocurrency marketplace.…

That sentiment is shared by a significant amount of people[1][2][3][4], it seems. I am also sympathetic to minimalism in life (owning essentials only) and in many of my (programming) projects (single-header libraries[5], minimal dependencies). I think I would be content with C, Bash, Python and SDL alone, if I wasn't so dependent on the need to "exchange my time for money". (And perhaps Rust as well.) References: [1] https://www.askonomm.com/blog/i-dont-want-to-do-frontend-anymore [2] https://jonathanwhiting.com/writing/blog/games_in_c/ [3] https://begriffs.com/posts/2020-08-31-portable-stable-software.html?hn… [4] https://copyanddesign.com/blog/the-benefits-of-static-websites [5] https://github.com/d26900/JamaisVu