wuch

How wrong was Robet Nozick in his argument about the Experience Machine [0].

[0] https://en.wikipedia.org/wiki/Experience_machine

Maybe it continues the historical tradition of Federalists vs Anti-Federalists:

"The primary opposition to the Constitution was based on it being a centralizing document that risked making the states a mere administrative arm of the central government. States' rights advocates like Thomas Jefferson, George Mason, Patrick Henry, and Elbridge Gerry were wary of the new document. The Federalists were aware of these objections and their opponents. Thus, in trying to head them off at the pass, they adopted the name Federalists to give people the impression, true or not, that they were for a federal form of government and not a national one. This forced those who opposed the constitution to be known as Anti-Federalists, which to the less attentive audience gave the impression that they were against federalism and thus for a centralized regime."

If it is recognized that Facebook is a media company, it will be legally liable for its content, and it will be forced to keep better track of fraudulent anonymous usage, like U.S. political ads placed by foreign customers.

What is exactly fraudulent about U.S. political ads placed by foreign customers?

"What sorts of decisions does he [sponsor] make? According to some network executives, he no longer makes decisions that deal with programming. Spokesmen for sponsoring organizations tend toward similar statements, but with a difference. They say they don't want to control programming, but insist on the right to decide with what programs their names or commercials will be associated. They leave it to broadcasting companies to provide suitable settings for this participation. The broadcasters do so.

Perhaps they are all saying that sponsorship has become so essential, so crucial to the whole scheme of things, that interference of the old sort is no longer necessary. A vast industry has grown up around the needs and wishes of sponsors. Its program formulas, business practices, ratings, demographic surveys have all evolved in ways to satisfy sponsor requirements. He has reached the ultimate status: most decision-making swirls at levels below him, requiring only his occasional benediction at this or that selected point. He is potentate of our time."

The Sponsor - Eric Barnouw

Quote from Conclusions chapter of Manufacturing Consent (from edition published in 2002, but I don't think this part changed at all since first edition published in 1988).

"A propaganda model has a certain initial plausibility on guided free-market assumptions that are not particularly controversial. In essence, the private media are major corporations selling a product (readers and audiences) to other businesses (advertisers). The national media typically target and serve elite opinion, groups that, on the one hand, provide an optimal “profile” for advertising purposes, and, on the other, play a role in decision-making in the private and public spheres. The national media would be failing to meet their elite audience’s needs if they did not present a tolerably realistic portrayal of the world. But their “societal purpose” also requires that the media’s interpretation of the world reflect the interests and concerns of the sellers, the buyers, and the governmental and private institutions dominated by these groups."

To provide a little bit more context, here is detailed description of this bug [0]. Curiously, they suggest that problem could be avoided by changing the check for EOF to ">=". This is not true at all in case of C, at least as far as language semantics is concerned. When pointer goes two past the end of array you are already in undefined behaviour land.

[0] https://blog.cloudflare.com/incident-report-on-memory-leak-c...

What issue do you refer to in context of Signal protocol?

(n+1)sec attempts to address the issue of transcript consistency, which is completely out of scope for megolm. Though, it puts additional requirements on the chart room, in particular "members of the chat room receive the same chat events in the same order". I wonder how well this works in practice; does XMPP chat rooms usually ensure this or not; what about flaky internet connection, etc.

OMEMO ensures neither room consistency nor transcript consistency. In fact, last time I checked you could easily send different transcript to different participants (for example by simply not providing them decryption key or providing an incorrect one; some clients do not provide any feedback to the user that something is going wrong).

"In England, at this day, if elections were open to all classes of people, the property of landed proprietors would be insecure. An agrarian law would soon take place. If these observations be just, our government ought to secure the permanent interests of the country against innovation. Landholders ought to have a share in the government, to support these invaluable interests, and to balance and check the other. They ought to be so constituted as to protect the minority of the opulent against the majority." -- James Madison

When I reached the comment field at the end of page, to my big surprise the name and email have been already filled in. In fact, it seems like data of the person last to comment have been present there. Something along the way have gone quite wrong.

My impression was that gtk has pretty reasonable tutorials, at least for those languages with official bindings. Once you go through tutorial, you can examine gtk-widget-factory app and gtk-demo app for further ideas how to implement common stuff. Or just take a peek at source code of an application that does something that you would like to replicate, even if it is written in a different language the knowledge is easily transferable.

I don't use gedit, but in general I like look and feel of GNOME 3 applications:

* Emphasis on undo instead of confirmation dialogs. Though, some applications got implementation completely wrong. Contacts, I am looking at you. It delays deleting a contact instead of offering a real undo, which means that if you exit early no action is performed at all.

* Different colors for constructive / destructive actions used consistently across applications.

* Keyboard shortcuts window. Though, I don't understand why most applications insist on making it modal, which essentially prohibits looking at shortcuts and trying them out at the same time.

* Headers bars. I prefer those over traditional menu bars, especially if number of different actions to perform is limited. Though, portability suffers as making it work in environments without client side decorations requires some custom code. Thus, if developer didn't take this into account it probably doesn't work.

* In-app notifications (used for example for example for undo I have already mentioned). Though, AFAIK this doesn't seem to be builtin part of GTK yet and require a little bit more custom code than other widgets.

* Empty placeholders! (Though, they might have been there already?)

Actually there is pretty limited support that placebo actually works on anything but subjective measured outcomes.

I do recommend Behave. Robert Sapolsky is terrific writer. Though, I found it quite funny how in each chapter Sapolsky starts by describing usually story, criticising how it is wrong and too simplistic, elaborating on complexities involved, but at the end of chapter can't resist giving one sentence blurb summary himself - which is of course almost equally simplistic.

In C++, you can for example:

1. Manage resources with RAII (though, in C you could use non-portable attribute cleanup in similar manner).

2. Use type safe wrappers around builtin types like in [0] and [1].

3. Use containers with more extensive bounds checking and iteration validity checks [1].

This could help detect some of those bugs at runtime, or even possibly prevent them from being written in the first place. Use of uninitialized value could be prevented with types that require explicit initialization or have default one (Bug 1). Left shifting a negative value could have been caught at runtime (Bug 2). Bounds check could prevent uninitialized memory read (Bug 3) Type safe wrappers could prevent an accidental promotion from being written in the first place (Bug 5).

Though, you need to go out of your way to actually do all those things, not to mention that your code would integrate poorly with existing library ecosystem. IMHO choosing C++ alone doesn't improve safety of your programs compared to ones written in C all that much.

[0] https://github.com/foonathan/type_safe

[1] https://github.com/duneroadrunner/SaferCPlusPlus

In pre C++11 it was quite typical for std::string to be implemented with COW semantics. Since C++11 standard it is no longer permitted, though it is not necessarily reflected in all stdlib implementations.

Using unsafe blocks and pointers can silence the borrow checker, but that doesn't mean that code is well defined. For example, using swap (mentioned in the article) with overlapping references would be undefined behaviour.

There are perfectly valid reasons to claim that exactly-once delivery is impossible. FLP impossibility result is not one of them. In fact in FLP model solution is trivial, just send the message exactly once and it will be eventually delivered.

* What about network failures? In FLP model network is reliable so there are no network failures.

* What about node failures? In FLP model node failures are permanent, so there is nothing illuminating to say that you cannot deliver message to a node that is permanently offline.

* What if node failures were transient? If network is still reliable and state transitions atomic, then failures are completely unobservable.

* What if state transition are not atomic, and you cannot process message and record that it has been processed in a single step? That would mean that exactly-once delivery is impossible even within a single node, and has nothing to do with distributed nature of computation.

A few things I didn't like about pass:

* It does not encrypt metadata.

* It performs delayed clipboard clearing instead of preventing further coping after first use, which is technically possible to implement, though I am not aware of any small standalone tool that does something like that.

* If you don't have something like YubiKey, password protection of gpg private key is not particularly impressive compared to the state of art.

I would argue to the contrary, especially that we are comparing modern Clang/LLVM with a GCC that was released back in 2008. At that point C programming language didn't even have a memory model.

I think you are looking at the side that does the reading. I was actually thinking about the other side that does the writing (inside pthread_mutex_init), where those two things are not separated by any function calls and are more readily reordered. Not to mention that it would be problematic on architectures with relaxed memory model either way.

In case someone is interested, here is relevant code [0]. Notice that mutexp is read without any synchronization, and _spinlock further down uses different lock than one in initialization code (former is specific to this mutex and latter a global one). There is no happens before relationship between mutex initialization and mutex locking. Thus, if different thread reads non-null value of *mutexp, there is no guarantee that writes done to the mutext structure itself will be visible. Given strong memory model of amd64 and i386, compiler would have to reorder pointer publication and structure initialization in pthread_mutex_init, unlikely but certainly a valid change given lack of synchronization.

[0] https://github.com/openbsd/src/blob/0ecb71b5ec9e4b22a484606f...

Now that OpenBSD has an optimizing compiler maybe they will notice and fix dataraces in their pthread_mutex_lock implementation. Currently they use broken double-checked locking pattern when mutex is lazy initialized with PTHREAD_MUTEX_INITIALIZER.

What exactly do you mean by "stealing each other keybindings"? From what you have described so far, it would seem to me that you are describing problem specific to X11 where global keybindings are often implemented in spyware manner, i.e., listening to all keyboard events (regardless of current window focus) and reacting accordingly. They may conflict with each other, they may interfere with each other, they may spy on user, in other words they are not working together at all.

There is no standard way to register global keybindings under Wayland yet, but this is bound to happen eventually. Not as a builtin part of Wayland, but it doesn't matter. It will of course use D-Bus interface, as KDE does it now for example - but if an application doesn't support this interface, it can't steal keybindings, it just doesn't get to install global keybindings itself.

Not sure what you have exactly against D-Bus, but clearly modern Linux desktop embraced it.

I always found Google reCAPTCHA to be pretty much unsolvable. Unless you turn off JavaScript in the browser that is, then it becomes easy. Which is pretty surprising, it would seem that it should work other way around - with JavaScript you should have more data points to make reliable decision. In accordance with this patent, another possibility would be that decision is in fact more reliable but I am just associated with malicious activity ...

Problem is not what your machine does with an USB device, but what the USB device does with machine [0].

[0] https://security.stackexchange.com/questions/118854/attacks-...

Note that the original article describes space complexity as "N + O(sqrt N)", i.e., there are N records and O(sqrt N) extra space.

Their data structure is considerably more complex than traditional implementations of std::deque, I wonder if it is actually of any practical interest.

That is good point, so far I see one potential explanation, but it presumes that clients are on equal footing with other peers in the system. Whenever you send a write and destination discovers that it doesn't have all of writes operations this write depends on, you send them as well. On the other hand, if clients are tracking only dependencies without actual data behind them, then I don't see how to ensure availability - maybe with fixed entry point to the system (one for each client), but then it is not exactly available.

EDIT:

I did look at the actual paper [0], they provide a strong consistency within local data center, and a causal consistency with convergent conflict handling across data centers. They presume that each client resides within a data center, so it is essentially a variant of fixed entry point solution I mentioned earlier.

Additionally, what it quite important, you lose causal consistency if client connects to different data centers.

[0] Don't Settle for Eventual: Scalable Causal Consistency for Wide-Area Storage with COPS

A lot of undefined behaviour on this list is quite specific to the C programming language, so it would be like comparing apples to oranges. Though, one major impression I think you will get after going through this list is that there is no good reason for making those things an undefined behaviour in the first place. For example, "The result of the preprocessing operator ## is not a valid preprocessing token", really?

Regarding those things that actually matter for programmer, following would be well-behaved in Rust (including unsafe blocks): conversion between types, integer arithmetic, pointer arithmetic (there are generally two variants of operations, one that essentially treats pointers as unsigned integers, and another one that behaves like in C with more opportunities for optimization). On the other side of the coin, in Rust mutable references cannot be aliased.