Early this year I finally broke down and subscribed to IRCCloud. They handle all the details of staying connected so you have access to channel history. Admittedly it works out to about 14 cents per day. Well worth it, in my opinion.

There are people working on a revised spec called ircv3, that aims to address those issues. I haven’t been in touch with that group, so I can’t speak to their progress or success.

I’m not very familiar with the legal details, but I assume the distinction is general access to the internet being considered a utility, while access to platforms being considered something like a privilege. E.g. roads shouldn’t discriminate based on destination, but that doesn’t mean the destination has to let you in.

edit: As to why Americans don’t seem as concerned with it (which is realize I didn’t address): I think most people see it as a place, like a restaurant. You can be kicked out if you are violating policies or otherwise disrupting their business, which can include making other patrons uncomfortable. Of course there are limits which is why we have anti-discrimination laws.

The landmark case in the United States is throttling of Netflix by Comcast. Essentially, Comcast held Netflix customers hostage until Netflix paid (which they did).

It’s important to understand that many providers (Comcast, AT&T), also own the channels (NBC, CNN, respectively). They have an interest in charging less for their and their partners content, and more for their competitors content, while colluding to raise prices across the board (which they have done in the past with television and telephone service).

Collectively, they all have an interest in preventing new entrants to the market. The fear is that big players (Google, Amazon) will be able to negotiate deals (though they’d probably prefer not to), and new or free technologies (like PeerTube) will get choked out.

Net neutrality is somewhere where the American attitude towards corporations being able to do whatever to their customers conflicts with the American attitude that new companies and services must be able to compete in the marketplace.

You’re right to observe that individuals don’t really enter into it, except that lots of companies are pushing media campaigns to sway public opinion towards their own interests. You’re seeing those media campaigns leaking out.

Switching to the individual perspective.

I just don’t want to pay more for the same service. In living memory Americans have seen their gigantic monopolistic telecommunications company get broken up, and seen prices for services drop 100 fold; more or less as a direct consequence of that action.

As other posts have noted, the ISP situation in the US is already pretty dire unless you’re a business. Internet providers charge whatever they can get away with and have done an efficient job of ensuring customers don’t have alternatives. Telephone service got regulated, but internet service did not.

Re-reading your post after diving on this one… We’re not really concerned about the same gatekeepers. I don’t think any American would be overly upset to see players like Amazon, Facebook, Google, Twitter, and Netflix go away and I wouldn’t be surprised to see one or more of those guys implode as long as they don’t get access to too much of the infrastructure.

Right-leaning US Citizen here. I’ll attempt to answer this as best as I can.

Net neutrality is being pushed by the media because it “fights discrimination”, and they blame the “fascist, nazi right” for it’s repeal (and they’re correct, except for the “fascist, nazi” bit). But without net neutrality, the ISPs still have an incentive to provide equal service, because otherwise they’ll lose customers (for obvious reasons).

I can’t speak to why open-source advocates are also pushing for net neutrality, because (in my opinion) the government shouldn’t be involved in how much internet costs. I do remember this article was moderately interesting, saying that the majority of root DNS servers are run by US companies. But, that doesn’t really faze me. As soon as people start censoring, that get backlash whether the media covers it or not

Side note, the reason you don’t see the protests against the “gatekeepers” is that most of the mainstream media isn’t accurately covering the reaction of the people to the censorship. I bet you didn’t know that InfoWars was the #1 news app with 5 stars on the Apple app store within a couple of weeks of them getting banned from Facebook, etc. I don’t really have any opinion about Alex Jones (lots of people on the right don’t agree with him), but you can bet I downloaded his app when I found out he got banned.

P.S. I assumed that InfoWars was what you were referring to when you said “removing some controversial users” P.P.S. I just checked the app store again, and it’s down to #20 in news, but still has 5 stars.

One part of it is that we already have net neutrality, and it’s easier to try to hang on to a regulation than to create a new one.

You’re overstating it. Most of the mitigation development of past decade or two was for Linux. Most of the high-security solutions integrated with Linux, often virtualizing it. The most-secure systems you can get right now are separation kernels running Linux along-side critical apps. Two examples. Some of the mitigation work is also done for FreeBSD. Of that, some is done openly for wide benefit and some uses BSD license specifically to lock-down/patent/sue when commercialized. Quick pause to say thanks for you own work on the open side. :)

So, what’s best for people depends on a lot of factors from what apps they want, what they’re trying to mitigate, stance on licensing, whether they have money for proprietary solutions or custom work, time for custom work or debugging if FOSS, and so on. One is not superior to the other. That could change if any company builds a mobile/desktop/server-class processor with memory safety or CFI built checking every sensitive operation. Stuff like that exists in CompSci for both OS’s. Hardware-level security could be an instant win. Past that, all I can say is it depends.

On embedded side, Microsemi says CodeSEAL works with Linux and Windows. CoreGuard, based on SAFE architecture, currently runs FreeRTOS. The next solution needs to be at least as strong at addressing root causes.

I absolutely love that the BSDs are switching to llvm.

What does this news story have to do with LLVM?

Yes and no. Snaps are the last of many tries to have a single, uniform package format among a lot of different Linux distributions. They can be installed on *buntu, debian, arch, fedora, opensuse, …. They also offer built-in sandbox.

You are correct that a lot of propritiatory software is using it to distribute packages because it saves some time, but that’s not the main goal of the format.

There is some strange things about snap: https://medium.com/@acam/im-afraid-for-the-future-of-ubuntu-2f41796073b2

Think docker for desktop apps. With all of the good and the bad it implies.

This reminds me of all the hoopla around the JVM as it was coming out: one language to rule them all! Distributing bytecode instead of compiled binaries! Write once, run anywhere! I see how WebAssembly improves on some of this story, but it still has a sameness to it, except it’s dubbed ‘open.’ As a user, why do I care? As a developer, why do I care? HTML 5 displacing Flash has meant that ads are more invasive and harder to block, honestly.

There’s a big difference between Java and WebAssembly. While you could totally imagine a bare JVM that just runs JVM bytecode, it always came with its standard lib, the TLS implementation and everything around it. And even then, the JVM needs to come with a garbage collector, which wants to take control of all memory. The teasing thing about WASM is that it only talks about portable code, but not about a portable API. It’s quite different from the JVM in the aspect that it isn’t a platform in itself.

That said, it’s still a little bit sad that this is only just being introduced in 2018.

Technically - OpenBSD has had various toolings (1, 2, 3 and others) to do this very task for quite a long time. But none of them were considered the correct approach.

Also, this is something that’s pretty unique to OpenBSD IMO. The end result is the same as with other systems.. sure. But this is unique among the unix world.

Q: What’s the difference?

Glad I asked! This is entirely contained within the base system and requires no tools beyond ifconfig!

Linux has ip, iw, networkmanager, iwconfig..(likely others)… and they are all using some weird combo of wpa_supplicant.. autogen’d text files.. and likely other things.

Have you ever tried to manually configure wireless on linux? It’s a nightmare. Always has been.

NetworkManager does a really good job of making it feel like there isn’t a kludge going on behind the scenes.. It does this by gluing all the various tools together so you don’t have to know about them. IMO this is what happens when you “get it done now” vs “do it right”.

NetworkManager@6c3174f6e0cdb3e0c61ab07eb244c1a6e033ff6e:

github.com/AlDanial/cloc v 1.74  T=28.62 s (48.2 files/s, 45506.1 lines/s)
--------------------------------------------------------------------------------
Language                      files          blank        comment           code
--------------------------------------------------------------------------------
PO File                          66         125328         161976         457879
C                               541          71112          66531         321839
C/C++ Header                    528          10430          15928          34422
XML                              59           1406           2307           6692
make                              6            885            229           5009
Python                           40           1189           1128           4597
NAnt script                      65            626              0           3968
m4                                8            237            123           1958
Lua                              11            212            453           1314
Bourne Shell                     21            232            238           1115
XSLT                              5             65              3            929
Perl                              4            166            243            480
Bourne Again Shell               11             30             35            241
C++                               4             62            121            178
YAML                              4             12              6            161
JavaScript                        1             33             21            130
Ruby                              3             39             92            110
Lisp                              2             15             24             23
--------------------------------------------------------------------------------
SUM:                           1379         212079         249458         841045
--------------------------------------------------------------------------------

VS

ifconfig@1.368:

github.com/AlDanial/cloc v 1.74  T=0.12 s (32.2 files/s, 58201.7 lines/s)
-------------------------------------------------------------------------------
Language                     files          blank        comment           code
-------------------------------------------------------------------------------
C                                2           1009            345           5784
C/C++ Header                     1              7             16             58
make                             1              3              1              6
-------------------------------------------------------------------------------
SUM:                             4           1019            362           5848
-------------------------------------------------------------------------------

Anyway - I guess my point is this:

• Almost every OS achieves this goal.. sure.
• Most have had this feature for quite some time.. agree (Including OpenBSD!).
• None of them have it implemented as simply and well-thought-out as OpenBSD.

Whats really sad is that the security of other operating systems can’t keep up despite having more man power.

That said, it’s still a little bit sad that this is only just being introduced in 2018.

Would you like to clarify what you mean by this comment? Cause right now my interpretation of it is that you feel entitled to have complicated features supported in operating systems developed by (largely unpaid) volunteers.

So is there really any difference between open(read(”/net/clone”)) and net_clone();

Yes: The fact that you can write tools that know nothing about the /net protocol, and still do useful things. And the fact that these files live a uniform, customizable namespace. You can use “/net/tcp/clone”, but you can also use “/net.home/tcp/clone”, which may very well be a completely different machine’s network stack. You can bind your own virtual network stack over /net, and have your tests run against it without sending any real network traffic. Or you can write your own network stack that handles roaming and reconnecting transparently, mount it over /net, and leave your programs none the wiser. This can be done without any special support in the kernel, because it’s all just files behind a file server.

The difference is that there are a huge number of tools you can write that do useful things with /net/clone that know nothing about what gets written to the /net/tcp/* files. And tools that weren’t intended to manipulate /net can still be used with it.

The way that rcpu (essentially, the Plan 9 equivalent of VNC/remote desktop/ssh) works is built around this. It is implemented as a 90 line shell script It exports devices from your local machine, mounts them remotely, juggles around the namespace a bit, and suddenly, all the programs that do speak the devdraw protocol are drawing to your local screen instead of the remote machine’s devices.

So is there really any difference between open(read(”/net/clone”)) and net_clone();?

Yes, there is. ”/net/clone” is data, while net_clone() is code.

I don’t buy it because the real protocol is what you read and write from the file, not that you can read and write files

Yes - but the read()/write() layer allows you to do useful things without understanding that higher-level protocol.

It’s a similar situation to text-versus-binary file formats. Take some golang code for example. A file ‘foo.go’ has meaning at different levels of abstraction:

1. golang code requiring 1.10 compiler or higher (uses shifted index expression https://golang.org/doc/go1.10#language)
2. golang code
3. utf-8 encoded file
4. file

You can interact with ‘foo.go’ at any of these levels of abstraction. To compile it, you need to understand (1). To syntax-highlight it you only need (2). To do unicode-aware search and replace, you need only (3). To count the bytes, or move/delete/rename the file you only need (4).

The simpler interfaces don’t allow you to do all the things that the richer interfaces do, but having them there is really useful. A user doesn’t need to learn a new tool to rename the file, for example.

If you compare that to an IDE, it could perhaps store all the code in a database and expose operations on the code as high-level operations in the UI. This would allow various clever optimisations (e.g. all caller/callee relationships could be maintained and refactoring could be enhanced).

However, if the IDE developer failed to support regular expressions in the search and replace, you’re sunk. And if the IDE developer didn’t like command line tools, you’re sunk.

(Edit: this isn’t just one example. Similar affordances exist elsewhere. Text-based internet protocols can be debugged with ‘nc’ or ‘telnet’ in a pinch. HTTP proxies can assume that GET is idempotent and various cacheing headers have their standard meanings, without understanding your JSON or XML payload at all.)

Myrddin looks awesome I suppose, but what’s the attraction for potential users/developers?

If you need to ask, why say it looks awesome?

So, how exactly does it prevent me from shooting myself in the foot?

A type system that catches most issues, runtime checks that catch many of the remaining ones. There are still gaps that you can fall through, and escape hatches that prevent perfect guarantees, but the gun rarely points at your foot by default.

“Fewer bullets in your feet” is not equivalent to “Rigorously proven to have zero bullets in your feet”

Right now, it’s generally maintained by hand, with the repo living here and mirrored in github as usual. The html is generated using ussm. Markdown is generated with a fork of sundown, which I’ve taught how to format code with the magic to make it runnable.

I’d like to look at automating/improving doc maintenance, but I haven’t had a chance to dig into it. One thing that I feel pretty strongly is that autogenerated docs from comments are often either poor quality because they lack tutorial sections and examples, or hinder readability through sheer verbosity, so I want something that can cross reference the code, but keep the explanations and examples separate.

I should definitely have the libmath documentation up – I did write it after all. Will look into where it went when I get home. Fixed.

Loads for me. Here’s the message with links for you:

“seL4 is an open source operating system kernel with a proof of implementation correctness and a cool capability system. A feL4 project is a Rust project that can be built to run in the seL4 context and make use of seL4 APIs.

The Robigalia project is the best example of prior art in this space. feL4 is distinguished largely by its aim to automate and simplify the development process.

Today we’re sharing cargo-fel4, an automation tool. With cargo-fel4, you can write a seL4 task in Rust, expose it through a prescribed entry point, and then build it along with the kernel.

cargo-fel4 provides code generation that helps accelerate projects beyond the boilerplate of setting up a seL4 application. feL4 uses a toml-based configuration approach that helps wrap the relatively complex CMake build system for seL4, and cargo-fel4 generates usable configuration files for multiple hardware targets.

For now, feL4 exposes only the system calls by way of Bindgen, as represented by the libsel4-sys library; however, we have plans to release more of our idiomatic and Rusty abstractions in the near future.”

This reminds me of a trope in the DIY (esp. woodworking DIY) world.

First, show video of a ludicrously well equipped ‘starter shop’ (it always has a SawStop, Powermatic Bandsaw, and inexplicably some kind of niche tool that never really gets used, and a CNC router).

Next, show video of a complicated bit of joinery done using some of the specialized machines.

Finally, audio: “I used for this, but if you don’t have one, you can do the same with hand tools.”

No, asshole, no I can’t. Not in any reasonable timeframe. Usually this happens in the context of the CNC. “I CNC’d out 3 dozen parts, but you could do the same with hand tools.”

I get a strong whiff of that sort of attitude from this. It may be that the author is capable of this. It may be possible to ‘do this with hand tools’ like Shell and some calls to mount. It might even be easy! However, there is a reason docker is so popular, it’s because it’s cheap, does the job, and lets me concentrate on the things I want to concentrate on.

My reaction was “if you had to write this much to convince me that there are easier ways than Docker, then it sounds like this is why Docker has a market.”

I’m late to the Docker game - my new company uses it heavily in our infrastructure. Frankly, I was impressed at how easy it was for me to get test environments up and running with Docker.

I concede it likely has issues that need addressing but I’ve never encountered software that didn’t.

IIRC those can be configured off if you only want to keep the init part.

I noticed that the 2015 mailing list post says .c files are cached, so some time between then and the 2018 public release it was disabled for C.

If I had to guess, the actual parsing pass is always going to be a lot less complex for C vs C++, so a simpler approach like ccache’s may get similar gains for less overhead generating & maintaining the actual cache.

I agree. I push caching as the general rule if checking if it’s in the cache costs less than the time to compile the file. I’d think that was true for most languages.

Oh believe me, I would like to blame Damien Bergamini for lots of things :) But that wouldn’t do the overall great results of his work justice.

KRACK was a common flaw across many independent WPA implementations. Which was quite surprising. It has been argued that it’s an 802.11 standard flaw because the standard authors didn’t alert anyone that the state machines described in the documents were incomplete and didn’t account for this issue. But of course the standard authors didn’t notice the problem either at the time.

wouldn’t you have to agree to an embargo in order to break it?

Yes, but if you don’t agree to it, don’t complain if you aren’t given disclosure.

How about blaming the people who created the flaw instead of the people trying to fix it?

Because that’s not a mutually exclusive position, and a transparent attempt to create a moral high ground where none exists. You can blame both the people who created the flaw and the people who trying to fix it if they act in bad faith.

Several essentials have made a disproportionate benefit on my career. In no order:

• find a job with lots of flexibility and challenging work
• find a job where your coworkers continuously improve themselves as much (or more) than you
• start writing a monthly blog of things you learn and have strong opinions on
• learn to be political (it’ll help you stay with good challenging work). Being political isn’t slimy, it is wise. Be confident in this.
• read programming books/blogs and develop a strong philosophy
• start a habit of programming to learn for 15 minutes a day, every day
• come to terms with the fact that you will see a diminishing return on new programing skills, and an increasing return on “doing the correct/fastest thing” skills. (e.g. knowing what to work on, knowing what corners to cut, knowing how to communicate with business people so you only solve their problems and not just chase their imagined solutions, etc). Lean into this, and practice this skill as often as you can.

These have had an immense effect on my abilities. They’ve helped me navigate away from burnout and cultivated a strong intrinsic motivation that has lasted over ten years.

One thing that I’ve applied in my career is that saying, “never be the smartest person in the room.” When things get too easy/routine, I try to switch roles. I’ve been lucky enough to work at a small company that grew very big, so I had the opportunity to work on a variety of things; backend services, desktop clients, mobile clients, embedded libraries. I was very scared every time I asked, because I felt like I was in over my head. I guess change is always a bit scary. But every time, it put some fun back into my job, and I learned a lot from working with people with entirely different skill sets and expertise.

I don’t have much experience either but to me the best choice that I felt in the last year was stop worrying about how good a programmer I was and focus on how to enjoy life.

We have one life don’t let anxieties come into play, even if you intellectually think working more should help you.

This isn’t exactly what you’re asking for, but, something to consider. Someone who knows how to code reasonably well and something else are more valuable than someone who just codes. You become less interchangeable, and therefore less replaceable. There’s tons of work that people who purely code don’t want to do, but find very valuable. For me, that’s documentation. I got my current job because people love having docs, but hate writing docs. I’ve never found myself without multiple options every time I’ve ever looked for work. I know someone else who did this, but it was “be fluent In Japanese.” Japanese companies love people who are bilingual with English. It made his resume stand out.

Four things:

1. People will remember you for your big projects (whether successful or not) as well as tiny projects that scratch an itch. Make room for the tiny fixes that are bothering everyone; the resulting lift in mood will energize the whole team. I once had a very senior engineer tell me my entire business trip to Paris was worth it because I made a one-line git fix to a CI system that was bothering the team out there. A cron job I wrote in an afternoon at an internship ended up dwarfing my ‘real’ project in terms of usefulness to the company and won me extra contract work after the internship ended.

2. Pay attention to the people who are effective at ‘leaving their work at work.’ The people best able to handle the persistent, creeping stress of knowledge work are the ones who transform as soon as the workday is done. It’s helpful to see this in person, especially seeing a deeply frustrated person stand up and cheerfully go “okay! That’ll have to wait for tomorrow.” Trust that your subconscious will take care of any lingering hard problems, and learn to be okay leaving a work in progress to enjoy yourself.

3. Having a variety of backgrounds is extremely useful for an engineering team. I studied electrical engineering in college and the resulting knowledge of probability and signal processing helped me in environments where the rest of the team had a more traditional CS background. This applies to backgrounds in fields outside engineering as well: art, history, literature, etc will give you different perspectives and abilities that you can use to your advantage. I once saw a presentation about using art critique principles to guide your code reviews. Inspiration can come from anywhere; the more viewpoints you have in your toolbelt the better.

4. Learn about the concept of the ‘asshole filter’ (safe for work). In a nutshell, if you give people who violate your boundaries special treatment (e.g. a coworker who texts you on your vacation to fix a noncritical problem gets their problem fixed) then you are training people to violate your boundaries. You need to make sure that people who do things ‘the right way’ (in this case, waiting for when you get back or finding someone else to fix it) get priority, so that over time people you train people to respect you and your boundaries.

The biggest mistake I see junior (and senior) developers make is key mashing. Slow down, understand a problem, untangle the dependent systems, and don’t just guess at what the problem is. Read the code, understand it. Read the code of the underlying systems that you’re interacting with, and understand it. Only then, make an attempt at fixing the bug.

Stabs in the dark are easy. They may even work around problems. But clean, correct, and easy to understand fixes require understanding.

Another thing that helps is the willingness to dig into something you’re obsessed with even if it is deemed not super important by everyone around you. eg. if you find a library / language / project you find fun and seem to get obsessed with, that’s great, keep going at it and don’t let the existential “should i be here” or other “is everyone around me doing this too / recommending this” questions slow you down. You’ll probably get on some interesting adventures.

Never pass up a chance to be social with your team/other coworkers. Those relationships you build can benefit you as much as your work output.

(This doesn’t mean you compromise your values in any way, of course. But the social element is vitally important!)

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)

I was on my way to BSDCant, but it turns out they’ve cancelled it. There’s nothing BSD Can’t do!

Enjoy!

PS: (I made this joke on Mastodon as well, with similar groans for responses).