skysight-inc/HackerNews huggingface dataset:
A few hopefully relevant thoughts about translating docs

1) translating a piece of english UI will almost double the length of it. That's annoying.

2) documentation is hard to write and to maintain, and sometimes it's hard to read and use documentation. Creating multilingual documentation is even harder, and it's nearly impossible to have an entire coverage of the docs in all languages, which leads to incomplete or outdated/incorrect documentation - which, as the saying goes, is worse than none. Multilingual software inevitably makes the documentation situation of a software worse. Trying to apply language A docs to a language B interface is hell.

3) documentation alone isn't part of the story; forum threads, answered support questions and that kind of discussion-style paradocumentation is ranges in importance from helpful to just full-on essential and that kind of stuff is never really translated. Trying to get help from a mostly english community for a software translated is hell.

4) The sublanguage used in a given UI isn't written in a given tongue; really, it's written in a pidgin made of the original language of the application plus the slang of the domain of the application, which is usually tied to one, say, culture or spoken language in particular; very large software also typically creates its own sub-language, which separates itself from actual tongue the UI could say to have been written in. After all, any description of a what a software does, expressed in a language evolved for the interaction of human beings in the real, material world, must be a vague and fragile metaphor. Translating metaphors is nearly impossible. It's hell. It's poetry, but when poetry is not the goal, it's hell.

That also means that to read the documentation and UI of an application amounts to learning the sublanguage of that application, which as I explained is different from the actual human language it was written in. I can understand that "save" means "serialize the relevant subset of the application state to a file" without knowing anything about the "dictionary" meaning of the English word "save". It's not the same thing. "Save" could be replaced by "blub" as far as I'm concerned, but it's convenient for people who speak english to associate "serialize" to the concept of preserving, of keeping. But it's not as important as the consistency of the language developed to describe the concepts and operations of that application. A single "blub" is better than "Save" and "Sauvegarder". Duplicating the pidgin a software develops for itself makes using that software a special kind of hell.

Conclusion: it's easy to end up in situations where I have to use french software here in Quebec. Most of my friends have laptops and phones with french UIs. It makes using them a pain in the ass.

I absolutely, deeply despise translated UIs; translating a UI is almost systematically a counter-productive activity. It's hell.
Some of his arguments look a little bit botched.

For example:
> Fallacy #1: "Systemd is multiple binaries, therefore it is not monolithic"

Well following Wikipedia (http://en.wikipedia.org/wiki/Monolithic_application) means either a non-modular application, or a self-contained application. In this sense either his counter-argument is simply wrong, or the examples list he gives at the and is wrong.

> Fallacy #4.1: "Unit files reduce complexity"

Here he compares the ca. 275.000 LoC of systemd with the 10.000 LoC of shell scripts used as initscripts on Debian. Lets ignore that the 275.000 LoC contains much more than the unit management in the systemd daemon. But why are the bugs always in the scripts and never in the shell as he claims? And sorry, I don't take his word that C is always more error prone than the shell. This is true when the shell is used for its intended purpose: to start commands, pipe btw them and having a little bit of flow control. For everything else you surely want to have a general purpose language.

> Fallacy #7: "Systemd gives you socket activation!"

Well, according to boot charts, socket activation is not only a marketing gimmick.

EDIT: Add Fallacy 7
My very first questions regarding a potential storage solution revolve around data loss:

1. Can we enumerate the data loss scenarios?
2. How is drive failure handled?
3. How may data be corrupted and such corruption detected?
4. For every data loss scenario, what is the recovery procedure?

Here is all I could find: http://rockstor.com/docs/faq.html#how-do-i-prevent-data-loss...

Of course, there is a wealth of information on such questions for standard RAID, but I would suggest for marketing purposes that rockstor synthesize available information (from the many relevant layers of data management) in a coherent fashion, specific to their product. It doesn't have to be deep, but it should be at least minimally comprehensive and broad, with pointers to more detailed, layer-specific information.

Also, it's fine if the recovery scenario is "restore from backup" for e.g. the scenario where data is deleted by an authorized user. If so, there should be at least a minimal "backup story".
Let me get this right. If we prevent student from knowing source code in CS then education will improve?

Or, if we allow students from remixing music and images in art studies, then their education is going to get worse?

Or if we allow students to take apart technical diagrams and improve on them, then their education is surely going down the hill?

Please enlighten us how such restrictions would help a student who want to learn, experiment and improve their skills. It might help akbar501 businesses if he could take something under bsd/mit and slap proprietary restrictions on them, but I do not count that as "benefiting education". Thats like me asking people to send me money in order to "benefit the economy".
Back in the days of hand made printed circuits, I randomly assigned both data and address pins on a microprocessor circuit, and got everything onto a single side with just one or two jumpers.

I felt so clever. Then I remembered that the program in the ROM assumed a particular bit numbering, literally while my board was bubbling away in the ferric chloride. Oops.

Rather than re-design the board, I thought about writing a program to rearrange my binaries, or make a socket adapter for the EEPROM programmer. The socket adapter won out.
"* if a lot of operations are supposed to happen in a sequential fashion, their code should follow sequentially.*"

He is absolutely correct in this. However, he's wrong with regards to the level of abstraction. Those "operations" should be part of functions that could be scattered all over the code base in whatever order they were written. But at the end of the day, they will be called sequentially right next to each other.

I've often found this to be the case. The developers I see that make these "god" functions are unable to write and compose their code in layers. They instead see the entire run (start->finish) of their programs as one giant series of "sequential" "operations". So what ends up happening is they've got high-level code, interspersed with low level io/networking/db calls.
I know its a tall order but any future in open sourcing some parts of the framework?
If you get tired of the switch statement, pattern matching is the functional dual of polymorphic dispatch.
Yes, simplicity leads to understanding and I don't understand why more people don't get this simple concept. I've dealt with codebases with such a horrendous build process that it doesn't matter what kind of sugar you sprinkle on top because making any change is practically impossible. That complexity has to live somewhere and if you offload it to the docker buildfile it's still in the buildfile. The problem at the end of the day comes down to the fact that most developers either don't understand enough to build proper build pipelines or they are lazy or they don't think complexity in the build pipeline is anything to worry about. Docker does not change those things.
Functionally evaluating functions
Really the only "monolithic" problems I see are with journald and logind. For the other pieces people don't want to use them and they don't have to. The fact that e.g. networkd can't run without systemd is fairly irrelevant since no one is asking for that; they're asking to not run networkd which works fine.
This. I would have been happy with anything that turned initscripts, which are often hundreds of lines, including tons of decisions and variables, into a simple declarative conifguration file. systemd seems to do OK at that, though I am vaguely uncomfortable with how tightly coupled things are in a systemd system.
What Android apps do you use that rely on native code?

All the ones that I'm aware of are either games or half-arsed ports of iOS apps.
great work. for anyone who wants an open source spreadsheet editor I can recommend handsontable
#GamerGate – An Issue with Two Sides
Does anyone write in style C and then refactor to style A/B? That gives you all the benefits of both styles..
If you didn't follow, it might be worth your time to search a little about it.

In a weird way, almost all 'news' websites are on one side, while the other side (gamers), are on youtube and some other social medias not yet censored. (Thunderf00t got his Twitter account suspended, reddit threads are being deleted...)

Journalists hating their readers, feminists, straight white males... DRAMAAAAA!
> If something is going to be done once per frame, there is some value to having it happen in the outermost part of the frame loop, rather than buried deep inside some chain of functions that may wind up getting skipped for some reason

> I do believe that there is real value in pursuing functional programming, but it would be irresponsible to exhort everyone to abandon their C++ compilers and start coding in Lisp, Haskell, or, to be blunt, any other fringe language.

"Here, let me dismiss functional programming, and by the way OCaml and other 'non-pure' functional languages don't exist, and functional programming languages aren't useful for anything 'real' so you should do your functional programming in C, and also you may want to dump everything in one long-ass function because I don't like deep stacks".

He's just rationalizing C traditions.
> i work in a pretty convoluted SharePoint environment

For some reason I intuited that you were not going to talk about how well the organization has dealt with said complexity. I'm curious if there is any way to FFI into sharepoint and start using tools that don't actively sabotage their users.
Swiss Bank Leaker: 'Money Is Easy to Hide' (2013)
If you mix a good quality accelerometer with a low quality one you get worse quality than the high quality alone.

The main problem that accelerometer have is that they are lineal sensors while human beings or animals use logarithmic ones.

What this means in practice is that it is very easy to saturate a sensor. You have sensors of 1, 2 or 3 maximun gs(gravity vectors of acceleration) while sudden movements could be bigger than that creating "out of range" samples.

What they probably do is use different scales for both accelerometers, giving them "HDR acceleration". E.g the low quality one at 10gs and the high quality at 2-3.
I don't know. This article keeps saying the new iPhone is very secure. It makes me think it might not be very secure.
For old fashioned RAM and ROM chips, you'd be OK, and you're probably generally OK with data pins.

Address pins are another matter. The Z80 had a built in static RAM refresh circuit, and there is some schtick about which addresses are refreshed as a group (rows or columns, I forget which). So, rearranging the address bus might result in some nasty surprises. And it might get even more interesting with more modern memory devices, which are way over my head.

On a whim, I got the Howard Sams book on the Z80 while I was in high school, around 1981, and I devoured it.
Congrats to SWU. You guys rock and are the example that there is still a lot of innovation to happen in the world of email.
You say "it's banned in Europe and Oz as a food additive" as if that was material or interesting. GMOs are banned in Europe too, but no one takes that as a serious indictment of GMOs. It is, rather, a demonstration of the anti-scientific stance of European law-makers.

If you have some data that increases the posterior plausibility of the proposition "Azodicarbonamide is toxic at the levels found in Subway bread", give it to us! Note that that statement is quite different from "azodicarbonamide is toxic at some level", because that statement is true of virtually everything and is therefore completely irrelevant to the question about it's use in Subway's bread.
At its core the problem game programmers run into is that game state is very globalized with a lot of dependency overlap. You can push around the data into different containers and declare dogmatic methods of access, but you always wind up with the same problems: The animation state depends on the physics. The rendering depends on the animation state. The physics of a local entity depend on its collision with the rest of the world. The results of physics depend on which things collided first. And so on and so forth.

And so games live within this environment of confusion over which things happen when. At every point there are a few defensive tools - queue up actions in a buffer, poll values instead of copying them, etc. - but the overall management of these concurrent, overlapping systems remains a challenging task lacking in silver bullets.
This looks pretty cool. Easier to use and nice gui.
Crazy website biases exposed by naughty words lists (the NSFW version)
The problem is the carpenter, not the hammer. Please stop blaming the hammers in your headlines.

The tool was used incorrectly and it resulted it badness. Bringing Docker into it is pointless. This would have happened with Salt, Fabric, Chef, Puppet, etc. with the same team.
Dart: Semantic Versioning
Is it similar to what Seene is offering? It doesn't do full scale 3D but close. http://seene.co/
+1. I think that's a wise observation.
He's missing the point about socket activation. The problem it solves is different: if you have daemon B that depends on daemon A, you want to express that dependency in the init system, so that it starts A before B. But just starting process A isn't enough to ensure that A is actually listening on the socket that B wants to connect to, since it takes some time to load the binary and do initialization. There's a race condition there, where B can try to connect before A binds to the socket. To fix the race, the init system needs to either monitor for the availability of the socket, or do it systemd-style where it opens the socket itself.
What's the license? I couldn't find any mention of a license anywhere. Lighttable itself seems to be GPLv3, so I assume its plugins are too?
Terrible logic. With this kind of logic anything can be justified.
The only data protection options I could find were Raid 1, and 10. (raid 0 is a performance option) and as data loss on attempting to re-silver a 3TB mirror is 1 in 5, data protection here is not enterprise quality yet).

The UI stuff is great, but the tricky bit about building a storage system is not provisioning it, or getting the access protocols right, it is all about finding all the ways that data can be destroyed (both silently and noisily) and guarding against them. So if you want to stick with the Enterprise target, then you need something like the ZFS On Linux page which describes every way you can get data zapped and how you will prevent that from happening.

If you want to be just an off the shelf "hey here's something that will make your access point into something like a NAS device." then you get to lose data when a disk goes bad, or a memory chip goes bad, or a network cable is loose, or the powersupply cuts out, or the cat knocks it off the table etc.
Well, I think it honestly harkens back to Google's original "Don't be evil" motto. I think most of the people at Google want to "Do the right thing" as long as they keep their jobs.

They want to find the right balance, the problem is I think a large portion of Google has lost their way in that regard due to the need to make Google more money. If the volume isn't growing fast enough, they have to find newer...higher margin...options to grow.
Where did you get your hilarious "data loss on attempting to re-silver a 3TB mirror is 1 in 5" statistic from?
What DL packages target AMD GPUs?
If they aren't called from anywhere else and they're only called once (in the parent), it might be better to inline them.

Doing so goes against the urge to decompose as much as possible but it'd make the code easier to follow for the next guy. "What does do_small_thing_X do?"

Even when the next guy is you, a year from now. Do you really remember what do_small_thing_X does?
That's kind of how the TMS1000 microcontroller (used in the Speak n Spell) works. Instead of incrementing the program counter on each instruction (like every normal processor), they saved a few gates by using a linear feedback shift register. The result is the program counter goes through a pseudo-random but predictable sequence. So they just program the code into the ROM in the same sequence and everything works just fine. (Some day I'll write a blog post about this, since it's interesting to look at the silicon that does this.)
>Linux/Unix has a significantly lower barrier to entry compared to Windows

Except that everyone and their grandmother knows how to use a windows machine and no one(relatively speaking) knows how to use linux.
iPhone 6, 6 Plus and Apple Watch: Studio on the Go for Audio Pros
AFP is generally faster than SMB and SMB2, but SMB3 should be faster than AFP. YMMV of course.
OS X has good package managers but they aren't as intwined with the os as aptitude or yum, for better or worse. Homebrew and Macports are the most popular package managers.
What if the problem actually is complex? Let's say that I'm building an embedded firmware module for a chipset that can only be compiled with a proprietary compiler under Visual Studio - and you're a Unix shop with Bamboo as the continuous integration server?

Then that means the Unix bamboo server needs a Windows agent that can execute the cross-compiler inside a MS VC environment. It certainly is complex, but what piece are you going to change?
"How does that analogy make any sense?"

Well, I told you that the blog forms a narrative, of which the entry forms a part. His reasons for reaching the conclusions in this entry is based on earlier investigations, which are detailed in previous blog entries. The accusation that this entry is lacking context is similar to claiming the same from reading the end of a book, in that of course it won't make any sense unless you actually have read the parts that form the context.

The his experiments with the language and basis for his statements is investigated in detail in the previous entries. When I point that out, you claim to be unwilling to read them because the last entry did not make sense. How is this NOT like having dismissed the last chapter as not making sense as a stand-alone story and refusing to read the rest?

Maybe your confusion simply stems from your interpretation of this as a "first impression"-kind of text? Here is his first real blog about his first impressions: http://owensd.io/2014/06/09/swift-future-for-app-developers....

The text we're discussing on the other hand is to be understood as an commentary on the language after using for quite a while.

To me (and just to put this in perspective, I've written well in excess of 10k LOC of Swift during the summer) his issues make perfect sense - when seeing them with a somewhat experienced eye. For example, issues with Swift generics isn't immediately apparent. It's only after using them for a while that you can say that the missing features ARE indeed lacking for everyday usage, and this is not just a theoretical problem.

Similarly, the problems with Optional isn't really obvious from the beginning. (And optionals seemed like such a win initially. Built in Optionals! The language built to support it everywhere. Seamless interop with ObjC. Safe unwrapping! Syntax sugar for flatmap etc etc. And then it ended up being just as much a burden as it was a help)

This would suggest that the very reason that you see this as "an uniformed post with several questionable arguments" is actually because you have very little experience in the language. Consequently you see what you believe are meaningless or "questionable" arguments, simply because you believe someone wrote the blog article with similar [limited] experience with the language.

Since his issues aren't obvious at a glance, you conclude that they are false, never entertaining the idea that they represent a much deeper understanding of the language than you have achieved.
I agree completely, and I think git vs. CVS is a good illustration of why people don't always understand the value of it. From a certain point of view, branching and merging was easier for most developers under CVS, because they never had to do it. It was a Big Deal and was done by special people. If you tell someone who is using CVS and never deals with branching and merging that they're switching to git, and oh, by the way, they'll be doing their own branching and merging from now on, that sounds like a horrible step backwards to them. Telling someone that you're going to make something difficult accessible to them can sound extremely threatening.
Really nice work, don't get beaten up because someone did it earlier or better; it's still a very valid learning experience.
That is great feedback for us. I've added a documentation issue with your feedback: https://github.com/rockstor/rockstor-doc/issues/37

We have added appliances <-> appliance replication recently, which can play an important role in recovering from bigger disasters.

We'll have all that documented. Please feel free to participate on our github.
The postgres daemon already works that way. Nearly every daemon that listen to a socket works that way (a few don't, surprizingly).

That's the point.
Not really. Inlining can be done by mechanically incorporating the called function into the caller, in a way that respects lexical scopes. This will result in identical semantics. Then the resulting bloated code is optimized: subject to caching optimizations, common subexpression optimizations and whatnot. These have to obey the usual rules for not deleting or reordering side effects. The issue you're referring to boils down to the fact that in an imperative language, we cannot assume that two occurrences of a variable X can be replaced by the same value, because X may have been assigned in between. So compilers have to do flow analysis to discover in what part of a call graph does a given variable have a stable value.

E.g. if we have a silly C function like

int accumulate(int x, int y)
{
global += (x + y);
}

and then call it in two places:

accumulate(s, t);
accumulate(u, v);

the inlining is almost like just macro-expansion of the above into:

{
int x = s; /* "parameter" passing */
int y = t;
global += (x + y);
}

{
int x = u; /* "parameter" passing */
int y = v;
global += (x + y);
}

we don't have to care about side effects when we are doing this expansion. That's the job of later optimization.

The later optimization pass can worry about things like whether global is volatile-qualified. If it is, then the best that can be done is:

global += s + t;
global += u + v;

these can't be merged or re-ordered. And so this stays faithful to the original function calls. If global isn't volatile, then more can be done:

global += s + t + u + v;
I'd like to know if anyone has anything nice to say about Sharepoint. As a user I find it miserable in all browsers, and have obviously avoided doing anything with it as a developer.
I would say that OOP makes a lot of sense on large code bases, but that it's also very easy (and dangerous) to get overzealous with object inheritance, interfaces, abstract base classes, etc.
"most open source tools and frameworks were developed for OSX, then ported to Windows or Linux"

gcc?