c3RlcGhlbnI_

Their github has all of the same info but also answers some very important questions about the service https://github.com/bear-metal/tunemygc?. Namely they tell you that it sets a bunch of environment variables and they tell you what information they collect.

What I want to know is why this needs to get recommendations from a web service. Do they have to collect a bunch of data to learn good recommendations for different situations? Isn't it much simpler to have an algorithm optimizing the parameters locally, or does that take too long to learn good values?

I have yet to come across a level that requires guessing. They definitely exist in theory though(uncertain whether the level generation algorithm is smart enough to eliminate them).

There are no multiple solutions due to an unstated constraint that resolves ambiguities. I believe it is that a blue cannot be surrounded completely by reds.

A big improvement over 0h h1. I never felt like I had to think when playing 0h h1. Every puzzle was solvable by searching for a series of patterns that had an obvious solution.

0h n0 seems to be just complex enough that sometimes you actually need to think about the problem. At least that is the case so far.

My favourite part is having slideshare tabs crash before they are done loading the page if I have the chrome's "experimental platform features" flag set.

The article is by ESR and in his mind "hacker community" is a very specific group. A group who happened to have their heyday when the game of life had just been published and Conway was still offering a prize for an infinitely expanding pattern. This makes it really more of a coincidental thing rather than a representation of any inherent trait of the community.

Though even for that community(and people now who really like the game of life) I don't think it is a great logo. Circles are not a very pretty or pleasant way of representing the game of life and it makes me think of a board game when I look at it.

Well, it does mention explicitly which parts are GNU extensions. But I see what you mean. I can write sed scripts fairly well at this point but clearly didn't internalize any of the notes about what is an extension, thus it is frustrating trying to get the non GNU versions to do anything at all.

I did not argue that the IoT won't expand dramatically, or even that it is not the more important of the two technologies. However my point is that wearable computing can't possibly divorce itself from from the IoT. Any wearable object with the ability to collect and upload data falls into both categories. By that token, if wearable computing is not going to break away as its own thing, it will just become a small part of the internet of things.

Though I do suppose that the trend of pretending we can magically fit a smartphone into a watch or a pair of glasses is going to fizzle. However that was never really more that fantasy(I mean Google X is about taking technology they expect to have 10 years in the future and trying to build it now). In the meantime the more modest wearable computing devices we can actually build(like smart onesies and smart insulin pumps) have been continuing their steadily accelerating progress along with the rest of the IoT.

To be honest I don't know how much he has improved on the manual. It is such a small language that you could easily read up to the the examples very quickly even if you aren't particularly interested in learning.

I would suggest just giving it a look directly at https://www.gnu.org/software/sed/manual/sed.html

Though be forewarned, something that neither document explains well is the actual syntax. As in how addresses and expressions can be used and how to read a script. The syntax is relatively simple to understand looking at some examples, but the lack of clear delimiters between the address, command, and command parameters can confuse beginners.

It is very amusing to see him predict that internet of things will "broaden" while wearables will "fizzle". He even links to an example of how silly an idea this is: http://www.engadget.com/2014/01/07/intel-smart-baby-onesie/

A watch that isn't a great computer, and doesn't work well as a watch, isn't going to be a great product. However there are so many other kinds of wearables that we can do well with modern technology.

One kind of wearable technology that we have now and are going to see a lot more of this year is the body camera.

There don't seem to be that many that work on text streams, which is what I was referring to. The ones I am aware of are awk, shell scripting languages(bash, zsh, ksh, etc.), and the ed like DSLs( sed, ed, sam, etc.). I think there are others that are not as widely used.

If you google stream processing language you will also get a whole bunch that are not text specific. They are definitely worth looking at if you are interested in building any kind of stream based language.

That manual is possibly the single most useful technical document that I have ever read. It has enabled me to write extremely powerful programs that no one I know can understand.

It would however be nice to have a tool with similar power but simpler, more comprehensible syntax. One of the other commenters linked to an interesting document on sam, which has a better control flow but equally arcane syntax.

I am glad that someone is working on a new stream processing language, it is a very interesting paradigm. However I hope that they provide some very robust tools for controlling input splitting. As I have spent too much time fighting with awk and wishing it was more flexible(it is frustrating always having exactly two levels of splitting with only matchers on the first and only inverse splitting on the second).

As is you would have to put in filters to resplit input into lines and that is very messy for something that you will need/want to do very often.

For example if you wanted to parse by character it would be wonderful to be able to do the following:

  STDIN | /./{|c|
    # stuff
  }

Even better would be if you took it a step further and offered something like regex pattern matching for the block input. e.g.

  STDIN | /\w+/{|word|
    /house/ {
      # when word is house
    }
    /car/ {
      # when word is car
    }
    {
      # default case
    }
  }

If you have effective syntax highlighting the benefit in his trivial example disappears. In cases like that you can quickly scan up a line of numbers because they appear very different from the identifiers and it does not matter if they are lined up.

Though such a solution has exactly the same edge case as vertical alignment: when the identifier lengths are very different things get hard to read. In which case it seems much more useful to be able to easily match identifier with value, rather than be able to scan values.

This is just me taking issue with the trivial example though. Even though it seems to be impossible to get a whole team to set up their formatters the right way, vertical formatting is pretty much a must for tabular data like 2D arrays.

(On a different note I am pretty sure that the kernel style guide is one of the most controversial in widespread use. It works because it is very strictly enforced. Not a good place to draw examples from)

You would probably not be able to distinguish an adversarial image with added noise from a normal image with added noise.

While it is difficult to locate the adversarial examples by random permutation, they do not appear to be extremely specific. The paper even suggests that they exist within specific areas of the input space. So depending on the size of said area, adding noise will just lead you to a similarly adversarial image.

Regardless they propose a better way of fixing the problem by just modifying the training algorithm to penalize networks that have a structure allowing this kind of error.

Neural networks can still perform arbitrary computations, despite this result, so there is no reason to try and manually fix up bad inputs when you can train the network to do it.

I made myself a simpler version of this a while back. I would simply put the rcfile in a folder and then host that folder with:

  python2 -m SimpleHTTPServer 12345

Then you can just use something like the following function to get a remote session:

  sshrc() {
    ssh -R 12345:127.0.0.1:12345 -t ${*:1} 'bash -c "bash --rcfile <(curl -s http://127.0.0.1:12345/sshrc)"'
  }

This has some nice side effects in that you can then just host your vimrc the same way. I think you can get vim to load plugins from a http runtime path too, but I have never looked into it.

Doing it this way has its own quirks though.