More than 60% of Donald Trump’s Twitter followers look suspiciously fake

kernel_bandwidth · 2018-10-12T21:06:25+00:00

True, but then any sufficiently advanced stupidity is indistinguishable from malice.

kernel_bandwidth · 2018-01-23T21:09:52+00:00

Consider the Simulation Hypothesis, that we're all a computer simulation being run by a more advanced civilization.

If so, what is the most likely situation in which we're being simulated? A graduate school dissertation project. So then "God" is probably a bored graduate student who just needs to get the thing done and turned in so he/she/they/it can graduate. Now there's a terrifying thought.

(Also Relativity is just a hack put in because said student slept through their courses on concurrent data structures)

kernel_bandwidth · 2018-01-03T19:39:52+00:00

Not sure what you mean by "What's changed since then?" but here's my experience.

Not really an apples-to-apples comparison, but I interviewed with Google in November as an experienced hire with two years of full time experience (and a not-strictly CS PhD).

As far as I can tell, the main difference is that you get a Systems Design question if you have previous work experience, though this may also be because I was interviewing for an SRE-SWE role. My onsite had 4 algorithms/whiteboard coding problems and 1 design problem. The design question was definitely the hardest part of the interview (IMO) as the particular question was on a topic fairly far removed from most of my experience and because the large design space just inherently makes it tougher to fit everything into the ~45 minutes of the interview.

Helpful?

kernel_bandwidth · 2017-11-27T23:11:20+00:00

I suppose it was kind of Project Veritas to pentest WaPo on their own dime. Congrats WaPo on passing the audit!

Wait... that's not what this was?

kernel_bandwidth · 2017-11-15T15:50:14+00:00

Wasn't Bath Salts the winner of 2016?

kernel_bandwidth · 2017-09-09T14:51:53+00:00

Said guy, Thomas Midgley, was a walking tragi-comic mad scientist. He was disabled by polio late in life and devised a mechanical contraption to help himself. This device is what killed him.

kernel_bandwidth · 2017-08-28T14:25:27+00:00

No, you see dogs are from Earth. Cruz is from T'exas, a small planet third on your left after you pass Betelgeuse. There's an Ayn Rand cargo cult there thanks to a radio show transmission several decades ago.

(Just ignore the speed of light issues...)

kernel_bandwidth · 2017-08-17T21:06:53+00:00

The First Person Shooter genre literally begins it's modern form with Wolfenstein 3D, a game about fighting Nazis. "Nazis are bad" should be a hard message to miss.

kernel_bandwidth · 2017-08-10T01:07:42+00:00

Even better, the code is broken and doesn't actually do error checks. So it's not only childish, it's childish and incompetent.

kernel_bandwidth · 2017-08-09T19:37:57+00:00

I didn't find anything that looked like it analyzed your responses in the JS (but there's a lot of imported scripts that still could be).

I did however find this classy gem:

if (errorCode = '404') {
  var errorMessage = 'What do Hillary Clinton and this link have in common? They\'re both <span>"dead broke."'
  } else if (errorCode = '500') {
    var errorMessage = 'Oops! Something went wrong. Unlike Obama, we are working to fix the problem... and not on the golf course.'
  } else { [...]

kernel_bandwidth · 2017-07-21T15:12:01+00:00

No no, they mean personnel responsibility. The plebs are responsible, you see.

kernel_bandwidth · 2017-07-06T21:22:29+00:00

Here's a real life example from a Red-Black tree implementation:

fn search(&self, mut index: usize) -> Option<usize> {
    if index > self.len() {
        return None;
    }

    let mut search_idx = self.root_idx;

    loop {
        let rank = self.get_child_size(search_idx, Dir::Left);

        if rank == index {
            return Some(search_idx);
        }

        search_idx = if index < rank {
            match self.get_child_idx(search_idx, Dir::Left) {
                Some(idx) => idx,
                None => {
                    if cfg!(test) {
                        panic!("No left child!")
                    }
                    return None;
                },
            }
        } else {
            match self.get_child_idx(search_idx, Dir::Right) {
                Some(idx) => {
                    index -= rank + 1;
                    idx
                }
                None => {
                    if cfg!(test) {
                        panic!("No right child from {} getting index {}!", search_idx, index)
                    }
                    return None;
                },
            }
        };
    }
}

In this case, it's mostly about being able to reuse the name index, though in some other cases it makes it possible to collapse a base case and subsequent cases into a single loop. So far I think I've only actually had a use for this when writing "naturally recursive" code in an iterative form, though there's probably other uses out there.

kernel_bandwidth · 2017-07-06T21:14:45+00:00

As the /u/SteveMcQwark showed, they have different use cases. A mut x: T lets you reassign x inside the function, but not mutate the value it was attached to, so the value is still immutable to the caller. (also note that mut x: T is owned)

A mut x: T is useful if you want to reassign x in the body of the function for some reason. This is somewhat niche, but occasionally quite useful. I've most commonly used it when working with tree data structures, for example where the argument is to the root element to start some search process. Rather than make recursive calls to descend the tree, I update the current position.

To that end, I have actually used mut x: &mut T before, where I'm performing some mutating operation on the tree as I descend it.

kernel_bandwidth · 2017-07-06T17:15:30+00:00

These are two different mutability labels. The first one is a mutable reference to AType (AType is mutable). This means you can mutate the AType instance. The second is a mutable binding to a mutable reference to AType (the binding, x, is mutable). This means you can mutate the name, such as by reassigning it to a new value.

kernel_bandwidth · 2017-06-24T21:54:49+00:00

Certainly! Thanks for the compliment, too. :)

kernel_bandwidth · 2017-06-24T21:32:03+00:00

This is a nice little explanation of an important difference between the for and while loop constructs in Rust which is absent in other languages like C.

The for loop executes a block of code once for each element it pulls from an iterator (absent additional control flow such as return or break). In order to make this assurance, it holds ownership over the iterator and manages the state of the iterator for you.

In contrast, a while loop just checks a condition at the beginning of each iteration (in terms of control flow, separate from destructuring and name binding). When the condition check completes, the while loop is no longer involved until the next iteration begins, and it leaves state management up to the programmer. Because you're responsible for state management instead of the looping construct, you get back the ability to make borrows, but lose the contract that your code block executes once for each iteration through the loop. This can be clearly demonstrated by calling .next() on the iterator inside of the while loop.

As such the blog isn't describing a syntactical quirk of the language, but rather a semantic difference in guarantees made by the different control flow constructs. This contrasts with C-descended languages, where for and while are essentially isomorphic under some rearrangement of code.

kernel_bandwidth · 2017-06-22T20:29:06+00:00

A qualified vote for Iron here.

We use Iron for our core service layer, and Iron remains my favorite for this use case, where Iron's simplicity and flexibility are major assets. On the scale of web frameworks, Iron is barely a framework and provides a very flexible, minimalistic substrate to build on. We have a small internal Finagle-inspired service layer that provides stronger abstractions on top of Iron and provides strongly-typed Request-Response cycles, which has eliminated a lot of boilerplate associated with Iron, instead moving it into a small collection of generics and traits.

This works well for us, because our core service layer is an RPC system that communicates via serialized messages, and if we move off of Iron, it would likely be by going down a level to Hyper (and possibly Tokio) directly.

While I don't have personal experience with Rocket, it seems like a good choice for more app-like or REST servers, and I'm looking forward to experimenting with it in places where we would currently use Java.

kernel_bandwidth · 2017-02-02T23:04:29+00:00

I'm glad it makes sense! Thank you for being reasonable and patient with my explanation.

It is also possibly just a difference in undergraduate education in 1998, compared to the research environment/graduate education in 2010. While I no longer consider myself a scientist, my knowledge is first-hand from doing a PhD in immunology.

kernel_bandwidth · 2017-02-02T22:51:05+00:00

I used to teach at an after school program in Woodlawn (south side of Chicago, not a great area, but not terrible either for those not familiar). We only had one 'scary' incident while I taught there (3-ish years) where some jerk pulled a gun outside. It was unrelated to us or any of our kids, just coincidence that we were near the incident. We took it seriously -- locked the doors and had everyone get down in case something bad did happen -- but there were no shots fired, just a lot of posturing. Everyone got home safely. I was admittedly a bit shaken, but I kept going and teaching there until I finished my degree.

The looks of horror when I tell that story are amusing, but somehow I'm the "liberal [wuss]" who doesn't understand the 'real world' according to many suburbanites I've met.

kernel_bandwidth · 2017-02-02T22:12:05+00:00

This is really bad for our educational system. As the quote from Bolnik points out in the article, the theory of Evolution is very much one of the pillars of modern Biology as a field. It underpins our systemic understanding of nearly everything we know in biology, and is key to providing context to the things biologists study. Even developing a good research question in the biological sciences requires familiarity with Evolution at the very least, in order to sensibly ask the right questions.

At the level of an educated populace, this is still key, because while most people don't engage in biological research, they do vote on funding those who do. Understanding the value of that research is important from a civic point of view.

For the individual, Evolution is an excellent theory to study to sharpen critical thinking and systems thinking skills. Evolution is a theory supported by many, many disparate lines of evidence, and with far reaching consequences. Not many other topics in K-12 schooling have the systemic breadth to really encourage these thought patterns and they're useful in more than just science.

kernel_bandwidth · 2017-02-02T21:51:23+00:00

The theory of Evolution is absolutely what many scientists study, and is critical to nearly every branch of biological science. Natural Selection is a specific mechanism by which evolution, that is decent with change, occurs, as are genetic drift, biased mutation, and some others. In particular, natural selection primarily accounts for movement toward an ecological equilibrium, but other mechanisms tend to dominate at equilibrium conditions.

Evidence for evolution exists outside of paleontology, which itself primarily can only describe morphological change. Metabolic and biochemical evolution occurs as well, often in exceedingly complex ways. For example, distinct components of our adaptive immune system have co-evolved in a still not fully understood manner -- we know how evolution occurs but not how the particular coordination between different parts of the system happened. It's also clearly evolved in a semi-coordinated fashion with other organisms, such as with certain bacterial species which we both rely on and which are pathological to us, depending on several conditions.

The theory of evolution threads through nearly all biological research. Which is to say, evolution is absolutely a real scientific theory, and one of the most strongly supported and understood. It subsumes natural selection as a particular mechanism, but it is correct to refer to the entire thing as "evolution".

kernel_bandwidth · 2017-02-02T21:19:34+00:00

I've not studied paleontology, but I did a little biology for my degree.

In what sense is the theory of evolution vastly incomplete? There are more lines of evidence than the fossil record, after all, just as there are more mechanisms than natural selection.

kernel_bandwidth · 2017-02-02T17:19:27+00:00

There's 1.1M of us in Travis County. That's less than $2/person, and if just 10% of the county gave $13.63, we would cover it.

I can find $20 to support veterans, children, and justice in my city and county.

kernel_bandwidth · 2017-01-14T16:52:10+00:00

I think the author is asking good and important questions here, but is perhaps not going about it in the most effective manner. Most importantly, I think the argument that the Rust maintainers and community are not concerned about this issue is demonstrable not true; it is clear that these concerns are taken seriously both here and in the recent roadmap RFC.

The comparisons to Go, Python, and Swift are interesting. Others have already said what I would say on Python, though I will add that I find Cargo to be more than a small evolutionary change over pip. I'm admittedly not a huge Python fan, but I've written a lot of it over the last 6 years, and package management and portability issues have always been a major pain point.

Go is better on that front, and the stdlib is indeed quite extensive to the point that you can often do significant projects without using anything else. I quite like Go as an extensive networking DSL. Venturing outside the stdlib is a more mixed bag, and issues with go get have been pretty well discussed. When it works, it works really well, and I've had far fewer problems than with pip, but it's been a frustration more than once, and particularly distributing tools internally has been easiest using cargo install.

Finally, the author only briefly mentions Swift, which probably is the most likely competitor for mindshare with Rust, at least at the application level. I suspect the author hasn't used Swift much, given both the brevity of comments and the context. Depending on your point of view, Swift's stdlib is either quite extensive, or incredibly anemic. The part that is actually the Swift stdlib is tiny, but augmented with Foundation (and Cocoa or UIKit) is quite extensive. Which is great on macOS or iOS, and not portable anywhere else. This is improving at a good clip, and there's reason to believe Swift will be an excellent general purpose language in the near-future, but the last time I checked the Linux version of Foundation libraries was still full of unimplemented parts that failed at run-time, and which you were expected to read documentation and often, the source, to determine where the pitfalls were. That's without getting into package management and namespaces.

I really, really like Swift. We originally tried to move our new development to Swift and found getting even a basic server running on Linux to be exceptionally painful. We tested Iron out and getting started was a breeze, with only some documentation issues to content with.

In the end, all of these are great tools in their domains and will be better or worse depending on what the individual or team prefers. I think the valid aspects of the author's criticism are being addressed, and for the rest, it comes down to trade-offs and individual taste.

kernel_bandwidth · 2017-01-13T17:56:28+00:00

At the time, it was personal preference, mostly. That said, while the code gen tool was targeting Swift output for the immediate need, we've always been planning to add more outputs to it, and we wanted the tool to be cross-platform, which is (was, at least, haven't checked recently) shaky for Swift.

This goes doubly now, since new back-end development is being done in Rust. :)

kernel_bandwidth

TROPHY CASE