timtadh

Have you tried shooting a node in the head and seeing what happens? Always a good exercise to run. Run a few disaster recovery exercises and see if you can get it back. I recommend doing that on non-production of course!

Don't get me started on setting up production hdfs and hadoop that is a nightmare. It is comparatively well documented with lots of people running it! As soon as you get into the weeds with kerberos and HA mode forget about the documentation explaining anything properly. Cargo culting from random blog posts, reading the source, and just playing around with config files is the name of the game. There are some weird interactions between KDC settings and some of the daemons that are not documented at all.

Twice the price was an exaggeration. However, as some one driving a XPS 13 dev edition (the original) right now they are definitely not priced as "cheap" notebooks. Someone has to write the drivers (or source components with good drivers) and make sure they work properly as configured. In the case of the XPS 13 dev edition Dell absolutely puts resources into at least trying to get that right. The laptop runs really well on Linux and many many laptops today do not because of driver issues. This is not news to anyone who has been using Linux longer than 5 minutes on real consumer PC hardware. In the old days, if you complained about hardware compat people would tell you to hack on the driver!

Well, I am the primary user of my command line applications as they are for my research. As the primary user they better be,

1. Easy to use

2. Have standardized syntax for flags across languages

3. Be easy to maintain

4. Be well documented so that I can use them a year or 5 years from now.

My applications often have complex syntax. For instance I work in frequent pattern mining, the basic syntax for some of my programs looks like:

  program [global options] -o <output> --support=<int> \
        <datatype> [data-type-options] <path-to-data>
        <algorithm> [algorithm-options]
        <filter-chains>
        <logging-and-serialization>

Being able to tightly control how the sub-commands chain together is important to me. Support for both short (-s) and long (--long) options make it easy to write both one off commands and self documenting commands in scripts and makefiles.

I write programs in more languages than just Go, and the programs in Go need to work the same way the programs in other languages work. That means GNU option syntax, which is the superior syntax for my needs in any case.

If you want to write command line apps that conform to the GNU flags convention you can't use the "flag" library. I wrote my own simple getopt implementation (github.com/timtadh/getopt) years ago so I could just get some work done. It works fine and has no dependencies. I write a lot of complicated command line applications and having a small simple getopt implementation makes it a lot easier. Sometimes a higher level tool would be nice but I have never found one I actually like.

Probably not the best idea to just tack the token onto the URL. There is a reason that people are not generally using tokens on URLs in lieu of cookies for session tokens. A better idea is to add a parameter in the POST body. This means that using this method all routes need a request body and you are therefore going to be mostly using POST in your API.

Thanks everyone for your feedback. I improved the post to discuss limitations of embedding and some workarounds.

Good point and definitely an annoying limitation. The work around is to use an interface as the expected type as I do in the lexing example.

I should have included a section on the limitations of embedding. This is what happens when I don't stew on the writing for a day or two before putting it out there! I will have to make a pass through the article and clear up the terminology. Thanks for the feedback!

Author Here: Good point. I had forgotten that the effective go document had a section on it. I will add the link. My main point is that Go embedding can be used as a form of subclassing allowing types to share, code, data or both.

@dang: Can we point this to the source article: https://mjg59.dreamwidth.org/42320.html ? "Circumventing Ubuntu Snap confinement" It is much better than the zdnet blog spam.

Case Western Reserve University as well (he did his undergrad here).

I think it is great that Jean (and Philip) both wrote these up. But, to be honest it 100% depresses me to read them. Graduate school has not been easy for me and I had no first author paper submissions for 5 years and ended up having to being part time for 3 years to support myself and my family. (My research is well in hand now. I finally submitted my first paper and have 2 more going out this calendar year. Sometimes it takes a while to find your passion/research area.) Given my family situation I am not able to do internships and in many ways I don't want to. I am going to go back to coding now because this is too depressing to read.

Most databases do have a way to force the index. See for example the MySQL way of doing it: https://dev.mysql.com/doc/refman/5.5/en/index-hints.html . You probably already know this but I mention it in case someone else does not.

That is great explanation from Linus. Thanks for linking it. He uses AFS (Andrew File System) as an example in that post which I think would be very analogous to ZFS. Linus says

  > Historically, there's been things like the original Andrew filesystem
  > module: a standard filesystem that really wasn't written for Linux in
  > the first place, and just implements a UNIX filesystem. Is that
  > derived just because it got ported to Linux that had a reasonably
  > similar VFS interface to what other UNIXes did? Personally, I didn't
  > feel that I could make that judgment call. Maybe it was, maybe it
  > wasn't, but it clearly is a gray area.

  > Personally, I think that case wasn't a derived work, and I was willing
  > to tell the AFS guys so.

So, the ZFS case is not cut and dried either way. It would probably take a court case to clarify the matter as it is in a "gray area". To me, there seems like there is a good chance than ZFS and the Linux Kernel can be distributed as a combined work (But I Am Not A Lawyer!).

    git diff --word-diff=color

provides a really nice word diff with coloring similar to this project. Just setup an alias in your global gitconfig:

    [alias]
            cdiff = diff --word-diff=color

This tracks well with a report I heard this week on declining mean salaries in the federal government versus industry. As the government pays less, has declining pensions, and is under constant threat of "shutdown" it isn't surprising that the best people would rather look elsewhere. That doesn't even factor in people choosing not to work for the government for political and moral reasons.

Sadly, this means that the bureaucracy will increase and become more petty. People will become more concerned about protecting their jobs and less about doing them well. Because, government work on a resume will become a "bad smell" making it hard for government workers to find a job in the private sector. Who wants to hire someone with a fake PhD? Only the government.

Another thread could 1) write to the same key. 2) cause a table expansion (or a shrink) which rehashes the whole table (in most implementations). Either case will cause a difficult to diagnose bug. Use a lock or communicate with channels instead. There may be other subtle things which can get corrupted under concurrent use. The map type in Go has never been implemented in a thread safe fashion so if you try and use it as such you will be in for a bad time.

In comparison to the new site the first sentence on the old one throws me off:

     Guile is the GNU Ubiquitous Intelligent Language for Extensions, the
     official extension language for the GNU operating system. 

Oh, so it is a language for writing plugins in. Kinda cool, but Python seems more newbie friendly than scheme for the same purpose. Might have a niche for some more scientific applications...

Compared to the new site:

    Guile is designed to help programmers create flexible applications that can
    be extended by users or other programmers with plug-ins, modules, or
    scripts.

That sounds much more general purpose. Maybe you would write the whole application in guile not just part of it.

That article explains the original post about alcoa downsizing than any of the other posts. Thanks!

While I do not agree with everything in this article, indeed some of its claims are suspect, I think it raises important points. There is a dynamic interplay between "science", the act of discovery, and "technology" putting knowledge to work. In my own work, the desire to accomplish a task drives my scientific work. All of my current work has a "natural application" in my field but has lead me to interesting mathematical questions which have potential applications elsewhere as well. Thus, the dynamic I have personally observed: progress in one space enables progress in another.

Furthermore, without individuals who are largely interested in knowledge discovery, I maintain that progress would be slower. Someone had to desire to understand cells and know about x-ray crystallography in order for it to be applied. I picked on this example because it was brought up in the article. But, by the same token, people interested largely in technological improvement are also needed. It takes a lot to move a discovery from a lab notebook into a useful state.

I also categorically reject the notion of technology being a thing unto itself that perpetuates itself. Humanity is the engine of innovation and no amount of innovation is likely to change that any time soon. All technology and all machines are ultimately at the service of humans. We are not in the service of the machine. We are dependent upon our machines but are machines are not free from us. This is why post-apocalyptic stories of AI destroying humanity remain popular. We are uncomfortable and fearful of our own dependence.

The fear of both scientists and corporations is we fundamentally do not know what the world looks like without government involvement. There is no roadmap for a transition. There is no telling who would win and who would lose. In the past several decades major research institutions both public and private have all had shrinking "time-horizons" for their research. The time-horizon is when the research (if fruitful) could result in technological advancement. In the short term a transition to industry funded research would only accelerate that trend.

In conclusion, science funding and science in general is deeply dysfunctional right now. A lot of time is spent of obtaining and keeping funding. Our funding system has likely caused a over supply of entry level researchers which has fueled low wages. But at the same time, we do not know of a better way to fund research at the moment. If non-governmental funding is better there is no real way to try it that won't cause massive structural unemployment and pain throughout our economy. As much as I would love to see the scientists I know receive good wages for their important work I think it is about as likely as properly paying pre-school teachers.

It is unfortunately hidden at the bottom as .mov in the supplementary information section: http://www.nature.com/articles/srep15180#supplementary-infor... .

Here is the Nature article that this video goes with. http://www.nature.com/articles/srep15180 .

Just buy the paperback or get it from the library. Actual books are great and have no ethical concerns unlike the ones the FSF has raised on e-books. Kindles are cool technology but a paper back is still better for actually reading. Libraries are fantastic and I still like physical books stores as well. If you "want to read what you want" the path is clear, read actual books.

Depends on the institution. I understand that higher tier research universities have a better graduate student ratio for domestic/non-domestic. My institution seems closer to 90% non-domestic for EECS PhD students.

emacs user! another to be expunged.

all hail <esc> as caps lock!

    for on that day,
        all shall be in normal mode,
      on the day of text
        one will `export EDITOR=/usr/bin/vim`

-- from the book of vim 2:12

I cannot upvote this enough. Go's dependency management is horrible. The fact that I have to encode my current github account to make things `go get`able is crazy! When projects move accounts or hosts it breaks everything. Not to mention that no one doing Go seriously actually uses `go get` to download dependencies. But, if you want the broadest audience for a library it needs to support `go get`!

There is furthermore, no way to build release packages that people can just install. There are no tarballs or jars or anything else that can be simply downloaded and depended on. So not only is everything tied to my github account I can't even release stable versions in any sane way. I never thought I would say "Man Java is really doing it right" but in comparison to Go it is!

I love writing in the language, but I solve this problem by mostly depending on only stuff I have written. That way I can at least control the problem. I have even started using submodules again! At least that way I can pin my dependencies to specific versions without having to use a third party tool. Insanity!

I wish facebook had not used "GraphQL" as their name for their SOAP/REST/RPC replacement. When I hear GraphQL I think of a query language for graphs. Like in (for instance) http://dl.acm.org/citation.cfm?id=1368898 . There has been a lot of cool research over the years on query languages for graphs. Facebook's "GraphQL" is totally nerfing Google's ability to find it.

Small single practices office are going away. Doctors are corporatizing either by merging with other practices or being bought out by hospitals or hospital groups. The reason: electronic medical records and new regulatory requirements. The burden of these regulations has been making it increasingly costly to run single doctor practices. So the result is less choice (in business) and less control for the doctor over the patient experience.

In conclusion, it is a nice idea to think of the doctors as "business people" but the reality is there are fewer and fewer who are. Most are now employees in a large corporate system.

(also +1 to the sibling comments)

Agreed. I hadn't seen the language before and it looks very interesting. I just spent half an hour browsing the site and came back to: "where did the discussion go?"

So true. I had to read the entirety of the JSP spec (and a few others) when I was an intern to help the company do some static analysis things. I also read a good chunk of Tomcat. Sun had this grand vision of App servers which you could just push code to and it would run completely isolated. The app servers where supposed to be spec compliant meaning your app could run on any implementation. But, and this is what bit the company I was working for, all of the implementations add lots of non-standard bits and broke standard bits. This meant that if you had written your app to go on WebSphere there was essentially no way it was going to run on TomCat without modification.

If Sun had more tightly controlled the marketplace for these things I think the whole ecosystem would have been more robust.