skysight-inc/HackerNews huggingface dataset:
> As do the BSD and especially(?) the Apache Software License.

Suppose someone forked BSD kernel, modified it heavily over years and made a closed source product of out of it (you don't actually need to suppose it anyway). Users get zero out of four freedoms they would have gotten with GPL.

https://www.gnu.org/philosophy/free-sw.html

As a user, you now can't freely run the kernel on multiple computers as you like, you are not allowed to investigate what the binary blob actually does on your hardware, you're not allowed to give a copy to your friend, and you're not allowed to make patches and redistribute.
So while this worked very well for some company and allowed them to launch a series of products in series quickly (which translated into billions in revenues), it screwed all of the four basic freedoms for all (paying) users.

Now tell me, how exactly is BSD license going to protect my rights as a user here?

As for the original developers of BSD, I'm guessing they might have been happier if that company contributed (some of) their changes back. Or maybe a few bucks from the billions of dollars they made.

BSD license basically gave the company to screw everyone else, both end users and original developers. Only a free software license such as GPL protects them both.

> make the code more resistant to forks, esp. less free

GPL doesn't have any restriction on forks. At all. Re-licensing and forking are orthogonal concepts.

> opens an option for the original author of code to do dual-licensing

That doesn't have anything to do with GPL itself.

> provides an opportunity for the authors to prevent certain uses of the code

It guarantees that four freedoms mentioned in the above link are protected.
It is probably annoying, if you work in a shopping center or somewhere were you cannot control the loudspeakers.

I never listen to a radio stations. I do listen to MP3 in the car, and carry some playlists with me (smartphone).
That's all totally fair. I really wish people weren't so quick to monkey patch things, especially when it comes activerecord.

"Eventually everything else you use will require newer 'x'", I think this is a problem even with non-frameworks. Imagine any core to your functionality lib getting far out of date. Dependency graphs are hard to manage over time.
Are we sure wiping out a mosquito will not wreak havoc? Eg (just an hypothetic illustration) starving out a spider species which results in another nefast insect to proliferate? Are we sure the mosquito is not a key element in the ecosystem? Really curious to know more on this.
The lunatic is on the grass

The lunatic is on the grass
este es falso, en mi experiencia. yo nunca he aprendido ninguna regla formal de español, pero puedo hablar más o menos fácilmente en esa lengua – algo que aprendí solo por hablar y leer, como cualquier niño. pero empecé cuando tenía 30.
Being an ignorant fool with an uninformed opinion, I would like to see a C compiler that is evaluated and critiqued not only based on the warnings and errors it generates but, more importantly, on the assembly it generates.

Namely, how compact and readable is the generated asm? When we read the asm, can we easily follow what the compiler has done and _why_?

As an ignorant fool, in my mind C is still a shorthand for writing assembly, to save old programmers from continuing to be or new programmers from becoming "assembly language programmers". Obviously many years have passed and "C" has become an institution and means much more to so many people. Aopologies to those people. I am just a fool.

I see the _theoretical_ "C compiler" as nothing more than a code generator, spitting out assembly. Obviously the _practical_ C compiler is very different. Base on the way it's used, it seems inextricably linked with a "preprocessor" (glorified sed).

It is said that asm has a "one to one" relationship with machine code. Theoretically, we can look at asm and determine its machine code equivalent without any "clever" algorithms.

My humble, ignorant fool's opinion is that it would be better if C had a closer relationship to the asm the "C compiler" generates.

Maybe not "one to one" but at least "predictable, boring".

Forgive me for having opinions about overly complex things few people can comprehend (e.g., a "modern C compiler"). I am just an ignorant fool who likes code generators. Especially ones that output assembly.
I'm looking for a new CLI library.

I like Click because it does very simple things very well. It gets hairy when you want to build more complex CLIs. For example, value options and validators don't play nicely because Click doesn't distinguish between the absence of a value and an invalid value, so you wind up dropping Click features and rewriting your own plumbing for that kind of stuff. The alternative is writing a more verbose CLI grammar, which leads to a really clunky UI.
The old fixed vs growth mindset at work. There is nothing to stop you becoming an exceptional engineer, except your beliefs of course.
Great read! Time to troll some of my machine learning co-workers.

"Can you classify this image of a panda? Oh, curious, it thinks it is a vulture..."
3 Things I Learned as an Engineer Doing Customer Support
Roaming Tiger Hackers targets Russian organizations for espionage
If you have high earnings in a market that you think has a low barrier of entry, you can expect worthy competitors to show up.
If you are the worthy competitor (No. 2) but maybe just cannot dethrone the number one, then you could decide to sell methods that make you a worthy competitor.

When more worthy competitors join because the No. 2 guy decided sell his secrets, top guy makes even less as the each participant's winnings are drawn from the pool. In this case profit margin is proportional to the difference in skill.

If you are the top guy, you could look on as the No. 2 guy establishes a solutions market (as your profits drop) or you could start the solutions market.

It seems like if you are the top guy, the main consideration is
How special/unique is my secret sauce? The answer to that and guides the second, When is the right time to become a solutions provider?

There will be market saturation with either your product or that of another entity. With time the game approaches to pure gambling and the money paid for the solutions becomes a Vig of sorts! Along the way sales would drop according.
If it involves "space ships, lasers and stuff" then it is, by definition, SciFi. SciFi is very rarely a genre all on its own.

To give some examples:

- Alien: Horror/SciFi

- 2001: A Space Odyssey: Mystery/SciFi

- Interstellar: Adventure/SciFi

- The Martian: Drama/SciFi

- The Force Awakens: Fantasy/SciFi
Not a bad way of organizing code, though, at least for relative beginners like me. I'm sure there are more clever things to do, or things that aren't quite possible to do reasonably or efficiently with independent small passes, but I like the way it lets me chunk everything I want to do. So maybe it started because there wasn't any other option -- but pretty good advice in the context of the article.
Perhaps a nanopass framework is of interest? "a compiler as a collection of many fine-grained passes, each of which performs a single task" http://www.cs.indiana.edu/~dyb/pubs/nano-jfp.pdf
You have to choose whether or not you want the compiler to generate code that spends time doing things that the programmer didn't ask for.

If you write a library with a function which accepts variables x and y and computes x[y] (or x<<y), there's no way for the compiler to know in advance whether the user will pass in well-behaved values for x and y. If you insist on the behavior being defined in pathological cases, then the compiler must add some kind of branching logic in there to check what's passed in at runtime. In other words, spend time doing things the programmer didn't ask for.

Maybe when we make more progress with formal proof-generating languages, we can create a "friendly" C where the compiler refuses to compile the code until it's accompanied by formal proofs of UB-avoidance.
And due to the design of CALEA (it dates back to 1994) they can't force Apple to do this easier, which is one of the things that started the entire encryption backdoor debate in the first place.
I went through a undergrad compiler class with the Dragon book, not the whole thing though, just enough chapters to build a compiler. We did build a full fledged compiler for an OO language, with all the parts of a compiler all the way to code generating assembly. It's kind of fast pace with too many stuff crammed into a class. Some theoretical topics were kind of fuzzy at the time. Still it was one of the best classes I have ever attended. Later on when I re-read the book on my own pace, I thought the book was the best thing since slice bread. Got a much better understanding of the theories behind the compiler topics. A lot of the things I learned I can still apply to this day.
You could do the same thing working at google, but instead of making $108k USD/yr, you would make +$250k/yr USD. Your time to target savings number would be greatly reduced. Then you can leverage that into a remote work position as you work from home in some cheap country.

You can also buy a condo in las vegas for $50k USD too. You still have a developed country where you can speak the language and the bay area is a cheap one hour flight when you need to get more work.
Quick tips on how to build user-friendly apps in 2016
If you use the ruler to directly measure the distance between subsequent points, the random temperature fluctuations will be as likely to increase as decrease the measured distance (of course for a real steel ruler, this would be dominated by the systematic error in the ruler's markings, which will accumulate over summed measurements).

If instead you used the ruler to measure (X, Y) co-ordinates of each point, then calculated the displacement between the points from those co-ordinates, the random errors would have a bias towards lengthening the path as in the article.
Its purpose is for education. It's a great course, and I wish Dybvig would create a Coursera.
Because the overwhelming majority of users of C compilers are compiling someone else's code that isn't narrowly targeted to the platform+compiler in question. So they get no benefit at all from specifying undefined behavior, but they do get a benefit from the performance gained by assuming away undefined behavior as dead cases.
Excellent. In regards how to best target the mosquitoes using this system this is still an open question, but it is now an engineering and political problem, not science problem.
Yes, which is why Apple has such a market share lead over Android.

Being the "first mover" is more often than not a disadvantage, and being one entails taking huge risks. ("Copycats" by Oded Shenkar is supposed to be a good book about this. Google "first mover fast follower" and "copycat innovation" to find additional relevant references. )
Understanding Global Assembly Cache (GAC)
Alpine Linux has packages for Inkscape.

This runs against the notion of minimalism in the context of a harness for containers in my view.
I'll take the bet that in 2035 it's still going to be C/C++ (or a C derivative like Boring C). Because rewriting all that code is an economic impossibility. There's a very long way to go before the rate of foundational Rust code written exceeds the rate of foundational C/C++ code written. And even if you manage to have 100% Rust and 0% C/C++ code being written, you still have a huge legacy to write, which literally costs billions of dollars (ALL operating systems, ALL browsers, ALL interpreters (Python/PHP/Perl/...), ALL compilers (GCC, LLVM), ALL web servers, etc.)

Honestly I think your view of technological adoption is fairly naive -- I don't see much content here other than "everyone get behind Rust!".

IMO the more realistic approach is a systems approach: make it so that badly written C code doesn't completely hose your system. I like the application compartmentalization work (Chrome style, DJB style), and capability work like Capsicum. And LangSec work in making safe parsers. The trusted computing base has to be reduced. Not every line of C code should run in a trusted context!!! Principle of least privilege. We know (or should know) all this stuff.

That is many of orders of less magnitude less work / cost, and I think actually feasible. Coherent and secure systems architecture is more achievable than everybody writing perfect C code or everybody switching to another language.

Another thing the Rust community should be working on is easy and efficient IPC with C programs. So you can rewrite a secure core in Rust and communicate with legacy C/C++ running in an untrusted OS context.

And also fixing the mess that is Linux containers, so it isn't so difficult to secure them (i.e. see Docker's security issues)
Yes we are as sure as we can be about anything in science [1], but even if it did cause some ecological issue it would be worth it given the misery mosquitoes cause.

1. http://www.nature.com/news/2010/100721/full/466432a.html
A warning on removed dead code isn't helpful because dead come is legitimately removed all the time. No one would ever heed it.
Curious how many here still listen to fm radio in your car?

This is my modern yet crappy car stereo set up....

1. iPhone

2. Car stereo tape deck with tape deck adapter into iPhone

3. Apple music

4. Siri to control what plays

What's yours?
This year I read a some cool papers:

Big Ball of Mud

Brian Foote and Joseph Yoder

About the reasons why good software become ugly and complex.

http://www.laputan.org/mud/

----------

The Inevitable Pain of Software Development

Daniel M. Berry

About changes of requirements for the software.

https://cs.uwaterloo.ca/~dberry/FTP_SITE/reprints.journals.c...

----------

No Silver Bullet

Frederick P. Brooks, Jr.

The software developing is in essense very complex.

http://www.cs.nott.ac.uk/~pszcah/G51ISS/Documents/NoSilverBu...

----------

Notes On Structured Programming

Edsger W. Dijkstra

Why we don't have to use goto.

https://www.cs.utexas.edu/users/EWD/ewd02xx/EWD249.PDF

----------

Watermarking, tamper-proofing, and obfuscation - tools for software protection

Collberg, C.S. ; Dept. of Comput. Sci., Arizona Univ., Tucson, AZ, USA ; Thomborson, C.

http://dx.doi.org/10.1109/TSE.2002.1027797
While I have sympathy for your friend, nobody forced him to stay on.

I have a couple of friends who own air conditioning and heating companies. They do very well now, yet they both started with one beat-up truck crawling in attics by themselves to earn a living. Years later they have employees and do well. They have both gone through surgeries of all kinds due to the punishment they subjected their knees and bodies to during their years crawling in attics doing duct work.

I know graphic artists who have had multiple surgeries on their wrists due to carpal tunnel injuries.

Carpenters who have lost fingers due to unfortunate accidents. And musicians with permanent Tinitus due to playing in loud environments for twenty years.

I spend my days working in front of a computer, probably 80 hours a week. There are consequences to that as well.

I guess the point I am trying to make is that all activities come with consequences. Yet not one of these people were forced to take and keep these jobs. Let's not blame employers for providing work people take freely. I am not justifying negligence in the case of unsafe working conditions. That is a criminal matter.
THE GIVEAWAY BLOG: Giveaway: WinX HD Video Converter Deluxe
LK Nhac Tre Hay Nhat 2015 HOT Remix Gai Xinh
> What would be the “long tail risk”? All the CRISPR-Cas9
> systems would die out with the mosquitos.

May I assume you have zero background in biology/biochemistry/chemistry?
Whose to say China isn't sending money straight to the regime? That's what it sounds like. How is that better than the West?
You're right; to be clear, what I was talking about above was whether the passes are decoupled at an abstract level, not so much whether the implementation uses multiple phases.

You can take LLVM "bitcode" as the product of clang, move it to another system with a different arch, and finish compiling the IR to a native binary on that system. This implies that the first step and second step don't share any state other than the IR itself—meaning that flags passed directly to clang in the first phase can't affect codegen, other than by influencing the generated IR; and that codegen has to treat the IR (and the environment) as its sole inputs.

Whereas with GCC, as far as I know, the RTL IR isn't arch-neutral, and the GENERIC/GIMPLE IRs aren't fully "baked" yet (i.e. they're compiler->compiler step IRs, not post-compilation pre-codegen IRs.) So there's no conceptual guarantee (even if there's an implementation-level one) that the compiler won't use compile-phase state to inform codegen.

In other words: it's guaranteed that you'd be able to implement the switches I'm talking about in clang+LLVM. You might (but won't necessarily) have to do some work to get GCC into the right shape to implement them.
One of them we know to be sentient. We can't be so sure about lions.

I'm not talking about higher-order intelligence, I'm talking about sentience -- the ability to experience.

It is rather simple now to find a program that would defeat the original formulation for a Turing test, but no one would describe them as having consciousness.

However, I believe it very possible that humans are doing much the same thing with a sort of sentience Turing test that we project onto animals. They _seem_ to have experience, because they react to stimuli. But the same is true of the computer.

We know that creatures with basically nothing in the way of a brain, take earthworms or severed octopus tentacles, will react to pain, hide from it.

We also know that pain has two parts -- a conscious experience, and an animal aversion. This is made clear by the existence of Pain asymbolia, where a person gets damage to the insular cortex (a lower part of the brain), and is no longer averse to pain, despite reporting that they still experience the pain just as they did before the injury.

I believe it quite likely that consciousness exists in the human brain alone, and is of very recent evolutionary vintage, evolving in conjunction with language. That when humans project sentience on their pets they are basically falling in love with a biological automaton, no different from a person falling in love with a chat-bot.

Unless we find a reason to believe that mere programming couldn't account for the behavior of animals (which seems increasingly unlikely, as our own rather rudimentary robots advance), it seems much more likely that evolution would have evolved the simple instinct system first -- only adding consciousness later on when it became an evolutionary necessity, as could have been the case for complex communication about qualia.
Internet think tank holds meeting on net neutrality
When you're saying that the compiler should be allowed to optimise under the assumption that OOB array accesses don't clobber other variables, this means that OOB array accesses can make very weird things happen indeed. For example:

if (a > 1)
b++;
array[b] = 0;
if (a > 1)
foo(a);

We might see foo() called with argument 0 when that's apparently impossible - the OOB write has apparently "reached forward" (it can also "reach backward").

This is why it ends up just being "undefined behaviour" - to do better either you have to somehow exhaustively document all the kinds of weird things that can happen ("it writes to the memory" isn't enough, because of the way that can interact with the optimiser) or you have to unreasonably constrain the optimiser.
Thanks. I agree that it is probably wise to give up on hard-earned specialization and pursue something seemingly lucrative in short term.

But I am slightly concerned if the semiconductor market itself is not very good in the long term, and software is.

I guess I am looking for a risk free way of testing if I could do better in software jobs in the longterm. I don't think there is ever going to be such an option.

May be next time I am looking for a job, I would take short break and try something different just to see how it is.
Yes, it is for one specific handshake, similar to many others. At a quick glance, the claims don't seem to cover any earthshaking innovation, but the introduction claims this makes it resistant to weaknesses in the underlying crypto algorithms that have been shown to be broken.
Race conditions are generally treated as "you get undefined behavior" for much the same reasons.
"Maybe when we make more progress with formal proof-generating languages, we can create a "friendly" C where the compiler refuses to compile the code until it's accompanied by formal proofs of UB-avoidance."

That's entirely feasible. I headed a team which did that for a dialect of Pascal over three decades ago.[1] It's since been done for Modula III, Java, Spec#, and Microsoft Windows drivers.

One reasonable thing to do is to have the compiler generate run-time assertions for every statement which has a precondition for defined behavior. All pointer dereferences get "assert(p != 0)". The shift problem in the original article gets "assert(n > 0); assert(n <= 32);" Now everything has run-time checks.

Then you try to optimize out the run-time checks, or at least hoist them out of loops. A simple prover can remove about 90% of the checks without much effort.

[1] http://www.animats.com/papers/verifier/verifiermanual.pdf
You give up some control of the company or enough control that shareholders own a majority stake, which is likely the case with the companies you mention. You also are subject to a boatload of new regulations and reporting requirements. Going public is a way to raise lots of money. It doesn’t really give a company any tangible benefits. Especially recently, companies that have gone public have ended up being valued at less than their last funding round.
Plain English is hardly succinct and precise either.

Repeat after me: "There is no silver bullet." There, that wasn't so hard.
A lot of people are calculating the cost of the book based off of MSRP and discounting it. However am I the only one that thinks he might consider selling the book above MSRP? In a way buying a book from here is an experience.
I really enjoyed it, but thought it was too derivative of the earlier installments, particularly the original trilogy.

Which I suppose is unsurprising given they are trying to bring the story back to its roots and not the infamous prequel trilogy, but I hope they are more original with the future installments and rely less on callbacks.

It honestly felt more like a New Hope reboot, than a new installment in the franchise. I sound pessimistic, but I really did enjoy it :)
My first piece of advice for startup job seekers is that equity, all things equal, you can’t pick ‘em. On a risk-adjusted basis, startups are likely to be about the same. If there is information that a company has significantly de-risked, it will be priced in. Despite the market often being very wrong, you are unlikely to outsmart it.

I don’t understand the argument for this. Isn’t the whole basis of venture investment being able to identify business that will return above the risk-adjusted return? Given many investors lack the technical understanding to know a good risk from a bad one how could this be priced in?
The shell doesn't have to be low-level. Curling the end-points directly probably would be. A client utility could wrap up higher level actions (which may involve hitting several end-points) with with a clean UI.
I don't find the "AAA" nomenclature worthwhile. So-called AAA development can be akin to factory farming and deliver garbage come release day. It's not necessarily doing anything right or wrong.

Quake was primarily a GOOD game, and if it must be classified further, a HIGH-END game.