You can use tee as well:

cat /dev/urandom | sudo tee /dev/fb0

It’s quite funny that person who don’t know how shell and sudo (nb: use doas or su instead) tells us a lengthy story about writing to framebuffers in Linux

This probably works for the author if they’re in the video group:

$ ll /dev/fb0
crw-rw---- 1 root video 29, 0  5 apr 15:37 /dev/fb0

EDIT: I’m stupid, didn’t see that part of the article.

Seems very unnecessarily frequent. If you had multiple search engines checking in this frequently it’d add up quickly

I like having a tap on caps mapped to esc, and a press mapped to ctrl.

Actual ctrl key I map to ctrl+opt+cmd and press with the palm for custom combos.

A monad is a type m for which the following functions may be implemented:

(>>=) :: forall a b. m a -> (a -> m b) -> m b
return :: a -> m a

Subject to the following rules:

-- Rule 1
return a >>= k  =  k a
-- Rule 2
m >>= return  =  m
-- Rule 3
m >>= (\x -> k x >>= h)  =  (m >>= k) >>= h

That’s it. That is what a monad is (there are equivalent definitions that some people prefer over this one, but all of them give the same result). Monads get some special treatment in Haskell (do notation requires a monad), but other than that there’s nothing magical about them. Monads aren’t magical things. “Monad” is a name for a common pattern: a type whose definition permits the functions defined above.

Don’t use RAII.

Isn’t RAII a hugely important technique for avoiding code problems?

As you say, to get by as “readable” you have to avoid a lot…

If you need a language that is fast as can be and type safe, D is much nicer and more readable than C++.

It’s like C++ but you can ask the compiler what it knows about any symbol and act on that knowledge at compile time.

Template meta programming in C++ is a complete nightmare… You can even ask the guy who invented template meta-programming and wrote The Book on it.

He went off and joined D instead since template meta-programming is simple, readable and straightforward in D.

“Don’t use the STL. Don’t use RAII. Don’t follow “everything has value semantics and a = b does massive allocations and copies”. Don’t use the STL. Don’t use smart pointers. … Maybe use the STL if you can’t be bothered to implement things yourself, but measure your build times before and after.”

Yes, definitely avoid exceptions if possible :)

1. RAII is one of the best things about C++.
   This is amazing:

database_connection db;
if (db.open("127.0.0.1", port)) {
  ...
}

// Don't worry about closing the connection no matter how we return from this function it will close

RAII should be exactly the same performance as the same code in C. The only time it should differ is if the C code avoided calling the “destructor” function before some of the return statements. You might have been confusing RAII with garbage collection or shared_ptr etc.?

2. Compile times are good enough these days to use STL on all but the largest projects. Use STL until you find a place where it is slow.
3. C++ users need to learn about reference vs pointer vs array, and move semantics, and then basically just wrap all pointers in unique_ptr or shared_ptr (And learn the difference).
4. I would really try to avoid writing your own string class. Add some axillary functions to convert between your types to and from strings, sure. It is fun and isn’t too hard to create a string library, but in commercial stuff, there is a lot to be said of being able to bringing people into an organisation and having them be able to hack on the code in the first hour because they have used std::string/map/list/vector before.

A better printf, use either of these:

With streams you can do this type safely:

my_log<<"x="<<x<<", y="<<y<<std::endl;

With var args templates in C++11 you can do this also with type safety:

my_log_function("x=", x, ", y=", y);

While I do mostly agree. It could be argued that the resulting code is readable but not writable or maintainable unless the next coder is already a capable C(or worse, C++) programmer anyway.

I myself ignore these concerns and write Objective-C++ on occasions when I think the performance boost is worth it.

[EDIT: This comment is largely wrong. Collections are 1-based, Streams are 0-based. It’d been so long that I’d forgotten. The point in general stands, but the code as-presented below will not work as expected; even when doing a range copy on a SequenceableCollection, it works 1-based with inclusive upper bounds. Doing a PositionableStream on the underlying collection will work as presented here. Sorry about that.]

That’s exactly what Smalltalk does.

c := #(a b c d e f).  "Declare a five-element array."
c at: 1. "a"
c at: 5. "f"
c at: 6. "throws an error"
c copyFrom: 0 to: 1. "#(a) EDIT: Nope, wrong!"
c copyFrom: 0 to: 5. "#(a b c d e f) EDIT: nope, wrong!"

This made instant and intuitive sense to me when I learned it as a kid in a way that 0-based indexing definitely did not, so I’m definitely on board with it. But I’d also note that in Smalltalk, as in many other modern languages, I barely ever even type the array index in the first place; doing things like first, last, allButFirst: 2, etc. are much more common. So I can’t honestly say it made a huge difference either way. (When I picked up Smalltalk’s successor, Self, I programmed in it for several days before I realized that its indices did in fact start with 0. And I only realized that because I thought I found a bug in the debugger.)

If you see everything as an offset from the beginning of an array, you can stop using the word index, and the confusion should stop.

Part of the point was that the icon is completely unparseable to a screen reader. Some users have limited sight, for which better visibility is relevant. Some users have no sight.

It’s usually not too complicated to spot, problem is the compiler generates an awful lot of assembly and you have to look in the right place(most of the output is optimal already).

It can be done in C++. It can still dangle, but that is another problem.

Clang has the __nullable and __nonnull annotations, don’t know if the optimizer takes them into account however.

It does, just not end-to-end.

[Comment removed by author]

Previously you’d be able to install the f.lux app using sideloading via Xcode (see https://justgetflux.com/sideload/#sideloading-flux-on-ios-with-xcode-7) vs. the previous requirement of a jailbroken phone. That ability was short-lived because it violated the iOS developer agreement. They’ve been having conversations with Apple for over 5 years asking for those APIs to be documented.

Even though Apple will now include this feature natively, it seems that the APIs f.lux needs will remain undocumented, and therefore unusable in a 3rd-party app.