Compared to “commonplace” things like cars and antibiotics? Internet, GPS, maglevs, a vast array of surgical techniques, the absence of smallpox…

Compared to “works but government and academia only” things like satellites and compilers? Hololens, quantum computers, drones, railguns, graphene, carbon nanotubes, metamaterials…

Compared to “wildly experimental and probably won’t ever happen” things like tokamak and nuclear airplanes? Probably a lot of classified shit. Antimatter experiments at LHC. Arguably a lot of work with AI

I think it is reasonable to say that the reworking of daily life has slowed.

The stove, the refrigerator and the car changed the routine of life tremendously.

The computer might be more impressive by any number of measures but it didn’t rework daily life so much as add another layer on top of ordinary life. We still must cook meals and drive around.

The linear extension of the car and the stove would be the auto-chef and the flying/auto-driving car.

Both things are still further than is sometimes claimed by the press but the seem a bit closer than 2012. However, the automation offered by externally available power, which began in the 1800s, definitely has reached a point of diminishing returns.

We may experience further progress through computers, AI and such. But this seems to hampered by a “complexity barrier” - an equivalent amount of daily life automation as various technologies offered earlier through power now requires systems that are much more computationally complex. Folding towels really does turn out to be the hard part of washing, etc and even with vast advances in computational ability, we may still be at diminishing returns.

There have been significant advances since then (for instance, in medical treatments like cancer therapies and surgery—life expectancy in the US has risen from 70 to 79 since 1960), but nothing revolutionary, that would seem remotely as magical as the developments across the first half of the century.

Relevant: https://www.reddit.com/r/AskReddit/comments/15yaap/if_someone_from_the_1950s_suddenly_appeared_today/c7qyp13/

It is. OpenBSD has an SROP mitigation, whereas HardenedBSD doesn’t. HardenedBSD has non-Cross-DSO CFI (Cross-DSO CFI is actively being worked on), whereas OpenBSD doesn’t. HardenedBSD also applies SafeStack to applications in base. CFI provides forward-edge safety while SafeStack provides backward-edge safety (at least, according to llvm’s own documentation.)

HardenedBSD inherits MAP_STACK from FreeBSD. The one thing about OpenBSD’s MAP_STACK implementation that HardenedBSD may lack (I need to verify) is that the stack registers (rsp/rbp) is checked during syscall enter to ensure it points to a valid MAP_STACK region. If FreeBSD’s syscall implementation doesn’t do this already, doing so would be a good addition in HardenedBSD.

So, there’s room for improvement by both BSDs, as should be expected. It looks like OpenBSD is starting the migration towards an llvm toolchain, which would allow OpenBSD to catch up to HardenedBSD with regards to CFI and SafeStack.

Sorry for the excessive use of commas. I enjoy them perhaps a bit too much. ;)

I haven’t read the whole article, because I’m not interested in HardenedBSD.

What is “theoretical” SMP? I’m running this from a 4-core OpenBSD laptop. You know, non-theoretically.

The article is indeed vague about it, but I think the author meant scalability issues. Too much time spent in the kernel space.

Same language snark goes with vmm: they tried to implement a hypervisor? I’ll be sure to inform mlarkin of his failure to execute.

I don’t have any experience with virtualization, but the point seems to be that you can only have OpenBSD and Linux guests under an OpenBSD host which compares less than something like bhyve.

SMP

From what I have read about SMP on OpenBSD its not that it would not detect 4 or 64 cores, its that its subsystems (like FreeBSD 5.0 for example) were not entirely rewritten to fully itilize all cores, that in many places still so called GIANT LOCK is used, may have changed recently, sorry if information is not up to latest date.

vmm

Now ints very limited, can You run Windows VM on it? … or Solaris VM? Last I read about it only OpenBSD and Linux VMs worked.

Is it up to date with the recent anti-ROP efforts?

I am not sure, You may ask here - https://www.twitter.com/HardenedBSD - or on the HardenedBSD forums - https://groups.google.com/a/hardenedbsd.org/forum/#!forum/users

I’m not sure, the article seems like it makes an honest enough comparison between hardenedBSD and OpenBSD that I make OpenBSD a priority to consider the next time I need truly secure OS.

Addressed in the Charlie Stross blog post I referenced in a comment in this thread:

why should we bet the welfare of our immortal souls on a single vision of a Basilisk, when an infinity of possible Basilisks are conceivable?

You can find it on google scholar: https://scholar.google.co.uk/scholar?hl=en&as_sdt=0%2C5&q=the+lambda+and+the+kappa&btnG=&oq=the+la

General purpose computers are not the best, but I’m more worried about isolation. In the worst cases a company might have a single network with their client databases on the same network as their development work and their “cloud” offerings. In the worst cases if you can pwn a lowly receptionist’s computer (Just leave a USB stick in the parking lot) then you have the keys to the castle.

Multiple networks are good, but they are frequently all connected to the internet anyway. I rarely hear about air gaps being used for anything but NSA or similar level operations. I think most companies could benefit from a few “offline only” restricted networks. Just simple air gapping can negate some of the risks of using general purpose hardware with proprietary OSs/software.

The situation seems almost exactly analogous to the situations that the FCC and electrical codes were intended to prevent.

A company isn’t allowed to sell an electronic device that emits strong interference to radio receivers. There are tests these things are suppose to pass. A company isn’t allowed to sell an electrical switch that kills one out of a thousand people. There are tests, similarly.

But somehow, the concept of “Internet interference” isn’t a thing. Obviously, it should be.

I’m okay with using computers for critical infrastructure – if and only if the entire stack is formally verified from silicon up. Almost nothing around today meets that standard.

One interpretation of Maslow’s hierarchy of needs is “if you’re having trouble finding enough food to survive, it’s gonna realllly tough to do things like maintain friendships or produce incredible art or scientific research.”

One interpretation of Dix’s hierarchy of software needs is “if you’re having trouble getting your tests to pass consistently, it’s gonna be realllly tough to do things like deploy continuously or split your monolith apart into microservices.”

You make a good point about the role of the CIA, and I wonder if it’s the globalization of software and hardware that is going to make such jurisdiction roles like the FBI, CIA, DHS, NSA much more confusing moving forward. Say the CIA in their efforts to gather intelegence on enemies of the state, discover something that can affect both the homeland and the enemy, what responsibilities are there for the CIA? Ethically, we should try to defend our citizens, but that’s not really the role of the CIA. Reporting it and getting the issue fixed could strengthen the defenses of the US and its citizens but then reduce our ability to attack or learn. Should the NSA try to strengthen our defenses, and in the process let the CIA know of any vulnerabilities it can take advantage of to eavesdrop on enemies?

Yeah,

I think it would be better that the CIA didn’t exist, that it’s very existence fundamentally undermines democracy.

That said, if the CIA is going to exist, them fighting out a sort-of equal battle with the black hats in the realm of target surveillance seems far preferable to the various NSA programs that involuntarily enlist corporations and individuals in a program of mass surveillance.

If the CIA suppressed a civilian agency or private company’s discovery of these things, it would be bad. But otherwise, this is doing the research that expect happens in “black hat” labs and foreign agencies.

On the other hand, EFF pretty much has to wag its finger at every misdeed. Their position prevents them from saying “oh but this is OK, I guess” since doing so would result in someone arguing something much “worse” would result

Did you miss the reference to the Vulnerabilities Equities Process?

I agree. I thought this was going to be about magazines, books, vinyl, or maybe the telegraph. A realistic title might be more along the lines of “Effects of technology and UX metaphors on individuals and society.”

The “diamond problem” and related questions wind-up ultimately problems of reducing a fuzzy world to a clear hierarchy. And this problem exists regardless of the programming and design paradigm you use.

Not necessarily. You can have objects without inheritance, as Go does, which avoids the diamond problem.

I don’t know why, but this linked article made my blood boil. What the kid did was FULLY CORRECT. If you’re going to argue that the teacher was correct you have to explain why the instructions were INCOMPLETE THEN! Sorry. I get angry because this hits the child really, really hard. It tells them the world is random and stupid people will deduct points (reject you, beat you up, slander you, pass you in life) even when you did every thing logically. It’s a lesson that can wait till they are 20.

What goes wrong with the naive streaming approach of m_1=x_1, m_n = m_(n-1) * (n-1)/n + x_n/n (possibly with some standard fp math tricks I don’t know about)?

It seems like something that would be in the published literature, but google scholar isn’t finding much for me. This paper has something related, an addition algorithm that minimizes error: http://dx.doi.org/10.1109/ARITH.1991.145549 - maybe it could be inspiration, or there might be something useful in that journal / by that author?

You still need double-length integers for “exact” average, tho.

So when you take the mean of a list of integers, do you use integer division? Is your final result also an integer? Do you sum the integers forever, use “infinite precision” arithmetic and return a fraction? I’m trying to think how this would work.

Lisp puts more emphasis on symbolic computation (concise expressions of lists and symbols) than the historical alternatives (FORTRAN, C, Pascal).

So, I’ll bite. I am a “functional programmer,” I guess you could say, in that I’ve taught myself a lot about functional languages, do problems and side projects in Haskell, and so on; but my day job is and has always been in imperative languages. For the last three years, I’ve written Java and Ruby. Before that, I wrote Python and PHP, and now I’m back to Python again. The omnipresent scourge of Javascript haunts me everywhere I go, of course, but that goes without saying.

I use functional principles when designing, refactoring, and critiquing code in all of these languages. I find that it gives me a clarity of purpose in places where other methodologies are “fuzzy,” where there aren’t easy answers or the answers that you can find are merely questions of taste. The approach I take centers around purity, immutability, transparency, and transformation-oriented code. I will use (anonymized) examples from a code review that I did today.

def generate_something(config, a_flag=True)
    if config['unrelated']
        fail "Cannot generate anything without the unrelated values!"
    end

    result = []

    config['things'].each do |thing|
        next if thing['foo']

        result << "#{@bar}/#{@baz}: #{thing}"
        result << "#{@bar}/#{@quux}: #{thing}" if a_flag
    end

    result
end

This is pretty typical code, I think, that people wouldn’t bat an eye at. It’s not beautiful, but it serves a purpose, and usually people wouldn’t be tempted to refactor it. In this code review, I made several points:

1. The test for the config['unrelated'] flag should be done elsewhere, because the values aren’t used inside the function.
2. The loop can be clearer if expressed as a transformation of a list.
3. Pass in only the data that is necessary; don’t use objects that know too much.

def generate_something(things, a_flag=True)
    things.select { |t| !t['foo'] }.flat_map do |t|
        baz = "#{@bar}/#{@baz}: #{thing}"
        quux = "#{@bar}/#{@quux}: #{thing}" if a_flag
        a_flag ? [baz, quux] : baz
    end
end

This is a more functional approach: it has less access to the outside world. It’s not modifying anything internally. Its loop is a transformation. This method almost has the type [Thing] -> Bool -> [String]. Almost, because there are those pesky instance variables. If I wanted to completely make this functional, I’d have the method accept a different argument:

def generate_something(things, string_templater)
    things.select { |t| !t['foo'] }
        .flat_map { |t| string_templater.call(t) }
end

This would give the method the type [Thing] -> (Thing -> [String]) -> String. It isn’t necessary, because the implicit self object is actually an argument to all methods, but that’s how it could proceed, if needed.

Why learn to do this? Ultimately, it’s because I like to have a set of principles which I can trust in the context of almost any problem. I think that many of the object oriented techniques that we have learned, in particular the SOLID principles and some “design patterns,” are halfway to functional programming from the “real world” side. That’s great! It’s good to have techniques that are proven in practice rather than theory; but without the theory, it starts to become difficult to know how to apply those principles in places where you don’t have any practice.

As another example, consider the “Null Object” pattern. Null is a problem throughout object oriented programming. Tony Hoare famously called it his “billion dollar mistake.” Fine: we can address it with the “Null Object” pattern, right? Except that, in order to make consistent use of this pattern, you need to implement a null object for every class in your system. You have to religiously use them, and they don’t even eliminate null checks.

if (pet == null) pet = Pet.NULL_PET;

On the other hand, if you approach this from a category theoretical perspective, you get… monads. The semantics of Maybe a work for all types a, because they must. It’s just math. There are no null checks because there are no nulls; if a null result is possible, then you’ll return Maybe Pet and be done with it.

What is confused about this? You’re not giving enough detail about what points are incorrect. This clearly isn’t a prediction of what will happen, but rather a philosophical waxing on what should happen. If it is conscious, and can communicate, should it not be treated with the dignity that other living beings are given? It might not care about life, or liberty, or the pursuit of happiness, but that does not mean that what it desires should be disregarded, provided that it does not impinge upon the rights of other sentient beings. We are all in this boat together, surely wisdom and history have shown us that if we are to work together in the years to come we should not act out in fear. If we can’t treat other sentient beings with respect, perhaps we shouldn’t build them.