Browsers rarely link out the system. FF/Chromium have their own PNG decodes, JPEG decodes, AV codecs, memory allocators or allocation abstraction layers, etc. etc.

It bothers me everything is now shipping as an electron app. Do we really need every single app to have the footprint of a modern browser? Can we at least limit them to the footprint of Firefox2?

Although you partly covered it, I’d say “execution of programs” is good wording for JavaScript since it matches browser and OS usage. There’s definitely advantages to them being smaller. A guy I knew even deleted a bunch of code out of his OS and Firefox to achieve that on top of a tiny, backup image. Dude had a WinXP system full of working apps that fit on one CD-R.

Far as secure browsers, I’d start with designs from high-assurance security bringing in mainstream components carefully. Some are already doing that. An older one inspired Chrome’s architecture. I have a list in this comment. I’ll also note that there were few of these because high-assurance security defaulted on just putting a browser in a dedicated partition that isolated it from other apps on top of security-focused kernels. One browser per domain of trust. Also common were partitioning network stacks and filesystems that limited effect of one partition using them on others. QubesOS and GenodeOS are open-source software that support these with QubesOS having great usability/polish and GenodeOS architecturally closer to high-security designs.

And more importantly, is there any (important to the writers) advantage to them becoming smaller? Security maybe?

user choice. rampant complexity has restricted your options to 3 rendering engines, if you want to function in the modern world.

When reimplementing malloc and testing it out on several applications, I found out that Firefox ( at the time, I don’t know if this is still true) had its own internal malloc. It was allocating a big chunk of memory at startup and then managing it itself.

Back in the time I thought this was a crazy idea for a browser but in fact, it follows exactly the idea of your comment!

In my daily job, this week I’m working on patching a modern Javascript application to run on older browsers (IE10, IE9 and IE8+ GCF 12).

The hardest problems are due the different implementation details of same origin policy.
The funniest problem has been one of the used famework that used “native” as variable name: when people speak about the good parts in Javascript I know they don’t know what they are talking about.

BTW, if browser complexity address a real problem (instead of being a DARPA weapon to get control of foreign computers), such problem is the distribution of computation among long distances.

Such problem was not addressed well enough by operating systems, despite some mild attempts, such as Microsoft’s CIFS.

This is partially a protocol issue, as both NFS, SMB and 9P were designed with local network in mind.

However, IMHO browsers OS are not the proper solution to the issue: they are designed for different goals, and they cannot discontinue such goals without loosing market share (unless they retain such share with weird marketing practices as Microsoft did years ago with IE on Windows and Google is currently doing with Chrome on Android).

We need better protocols and better distributed operating systems.

Unfortunately it’s not easy to create them.
(Disclaimer: browsers as platforms for os and javascript’s ubiquity are among the strongest reasons that make me spend countless nights hacking an OS)

zing :)

Yes, this C library is actually used by a lot of CLI utilities (zsh, bash, …), making all the keybinding listed in this Wikipedia article available in a lot of programs.

For example, the Ctrl-_, Alt-l are actually really useful in a shell context.

It is maybe common knowledge, but I just discovered that recently. I though it may be useful for some other people. I was apparently wrong.

I have trouble understanding why this is off-topic though.

For software version control? Probably very little (especially as you included mercurial in the alternatives)

I think however, that SVN could be the basis of quite a good self-hostable blob/file storage system. WebDAV is a defined standard and accessible over HTTP and you get (auto-)versioning of assets for ‘free’.

I know some game studios still run subversion, because of large art assets along side code, and the ability to check out specific subdirectories.

SVN is still heavily used by companies that are not pure software dev shops yet still produce their own software, e.g. in the financial sector and manufacturing industry.

I don’t think many people on lobsters still encounter SVN at their place of work, but that is due to lobster’s demographic rather than everyone on the planet migrating away from SVN. That is not the case. (Some people still use tools like ClearCase at work!)

What gets more contributions in code or dollars by companies using it right now? BSD/Apache or GPL software? And on top of that, which gets used the most by companies intending to turn the use into money to pay for laws and court decisions to limit software compatibility or freedom?

Those are a start at answering which to do if wanting mutually-beneficial uptake. I think the second question isn’t addressed nearly enough by GPL opponents. Saying that as a long-time advocate of BSD-style licenses that really reconsidered after watching the patent and API copyright action over time.

What war in 1848 are you getting at? Mexican-American war? Opium war? 1848 uprisings in Europe?

I’ve often wondered that. A long time FreeBSD-er I know talks about the distro never really recovering after the BSDI merge.

DragonFly has pf too: https://leaf.dragonflybsd.org/cgi/web-man?command=pf&section=4

I don’t think they’re comparable anymore. I think you can compare dragonflybsd more to openbsd than to freebsd. They’re a relatively small project with a strong philosophy and project goal who are very good at what they do (in this case performance), but they have a lot of quirks that might leave some users uncomfortable while they make hobbyists very enthusiastic.

As such they don’t shy away from removing features that they judge aren’t meaningful to their users/community anymore (non-amd64 support, some older network interfaces, some legacy code that’s still in freebsd but not in dragonfly). The project philosophy is so different that the parallels you can make from them coming from the same root aren’t entirely accurate anymore. Keep in mind the fork happened 15 years ago, with development happening independently over that time. That’s also important.

Also, dragonfly has ipfw3 and pf. According to the documentation (https://www.dragonflybsd.org/docs/ipfw3/), ipfw3 was written from scratch.

I’m guessing it’s not to be taken literally, but although I have heard of the connections between Python and Lisp (map, fliter, lambda, …) I haven’t heard about the second connection. Wasn’t FORTH invented in the 1970’s and LISP in the 1950’s?

I think the idea is that Lisp is a delimited, prefix language (e.g. (foo (bar baz) quux)) while Forth is an undelimited, postfix language (e.g. quux @ baz @ bar foo, where baz & quux are words which put an address on the stack, bar is a word which pops a value from the stack and pushes a value on the stack & foo is a word which pops two values from the stack and does something).

You can imagine that one could work up to a Lisp from something like OPAREN quux OPAREN baz bar CPAREN foo CPAREN in Forth, where OPAREN & CPAREN are special Forth words which do the obvious thing.

Its nothing so profound. Just a remark about syntax. Its almost as bargap explained. To go from Lisp to Forth

(foo (bar baz) quux)

Put the function at the end of the list instead of the beginning so (func arg1 arg2 arg3) becomes (arg1 arg2 arg3 func).

((baz bar) quux foo) 

And remove the parenthesis

baz bar quux foo

This should produce the same output when run in Forth. (Assuming constants are functions with no parameters and return the constant. And adjust for autoquoting and implicit returns.)

The same goes for the Python to Lisp transfomration. Replace all syntax with calls to their dunder equivalent, put the functions inside the parenthesis and remove the comma separators (func(arg1, arg2, arg3) becomes (func args1 arg2 arg3)) and turn indented blocks into quotes (and put them as the last argument of the block heading).

I still don’t see the link they’re trying to make with lisp and forth, especially considering their lisp example looks and seems nothing like lisp…

consider their example

bind("fib" fun([i]
               [if(<(i 3) [return(1)])
                return(+(fib(-(i 1)) fib(-(i 2))))]))

against common lisp

(defun fib (i)
 (if (< i 3)
  1
  (+ (fib (- i 1)) (fib (- i 2)))))

agreed, I would have expected a case study to go find some real world equivalent code written in each and then look for problems.

That would mean they had to allocate 2.1GiB * sizeof(int) (or at least 1.05GiB * sizeof(int)). Even so, calling malloc on a negative integer would just have it return NULL in new_data, so the assert would fail and the program would be terminated before anything bad happens.

#define a (++i)
int i = 0;

if (a == 1 && a == 2 && a == 3)
    ....

This is very easy to do in C++.

You can also do it with Haskell.

Doable with Java (override the equals method), and as an extension, with Clojure too:

(deftype Anything []
  Object
  (equals [a b] true))

(let [a (Anything.)]
  (when (and (= a 1) (= a 2) (= a 3))
    (println "Hello world!")))

Try it!

Or, inspired by @zge above:

(let [== (fn [& _] true)
      a 1]
  (and (== a 1) (== a 2) (== a 3)))

perl can do it very simply

my $i = 0;
sub a {
	return ++$i;
}

if (a == 1 && a == 2 && a == 3) {
	print("true\n");
}

Here is a C# version.

using System;

namespace ContrivedExample
{
    public sealed class Miscreant
    {
        public static implicit operator Miscreant(int i) => new Miscreant();

        public static bool operator ==(Miscreant left, Miscreant right) => true;

        public static bool operator !=(Miscreant left, Miscreant right) => false;
    }

    internal static class Program
    {
        private static void Main(string[] args)
        {
            var a = new Miscreant();
            bool broken = a == 1 && a == 2 && a == 3;
            Console.WriteLine(broken);
        }
    }
}

One of the ‘tricks’ where all a’s are different Unicode characters is possible with Python and Ruby. Probably in Golang too.

In Scheme you could either take the lazy route and do (note the invariance of the order or ammount of the operations):

(let ((= (lambda (a b) #t))
       (a 1))
  (if (or (= 1 a) (= 2 a) (= 3 a))
      "take that Aristotle!"))

Or be more creative, and say

(let ((= (lambda (x _) (or (map (lambda (n) (= x n)) '(1 2 3)))))
        (a 1))
    (if (or (= 1 a) (= 2 a) (= 3 a))
        "take that Aristotle!"))

if you would want = to only mean “is equal to one, two or three”, instead of everything is “everything is equal”, of course only within this let block. The same could also be done with eq?, obviously.

Here is a Swift version that uses side effects in the definition of the == operator.

import Foundation

internal final class Miscreant {
    private var value = 0
    public static func ==(lhs: Miscreant, rhs: Int) -> Bool {
        lhs.value += 1
        return lhs.value == rhs
    }
}

let a = Miscreant()
print(a == 1 && a == 2 && a == 3)

The fact that its ZFS filesystem was configured with lz4 compression while none of the others had any compression at all might have something to do with it. Decompression is done per-block, and each block was configured to be 8K bytes, and the more concurrent requests are made to the filesystem, the higher the chances are that different blocks might be requested, the more data the filesystem actually has to decompress before actually having a reply, even after fetching.