skysight-inc/HackerNews huggingface dataset:
Another interesting opportunity is data journalism and news application development: every project is on a 1-4 week deadline and because every news app / data visualization / ... is a standalone thing with no maintenance burden, you can mess around with new tech all you want, as long as you hit those deadlines.

There's also academia -- though even there, you will need to follow through and translate your learning into something you can communicate to the scientific community.
I wonder how this approach (single file + log) compares to the other usual approach (write second file, move over first):

1. Write changed the data into a temporary file in the same directory (don't touch the original file)

2. Move new file over old file

Does this lead to a simpler strategy that is easier to reason about, where it is less likely for programmer to get it wrong? At least I see this strategy being applied more often than the "single file + log" approach.

The obvious downside is that this temporarily uses twice the size of the dataset. However, that is usually mitigated by splitting the data into multiple files, and/or applying this only to applications that don't need to store gigabytes in the first place.
Electron “Lifespan” Is at Least 5 Quintillion Times the Age of the Universe
Mine aren't offered in autocompletion nor do they shadow normal subdirectories (maybe because I'm using bash in /bin/sh mode, and I have ".:" as the first component, respectively?).
Hey, you're in Switzerland? Near ZH? I'm doing something similar to you, multiple irons in the fire. Maybe we could meet up?
This is what Racket is made for (among other things of course).

I strongly recommend asking on the Racket-users Google Group as they'll know more about educational use than I, but Racket is actively used to teach 13 year olds programming in maths at school, and the basic Racket education program doesn't even teach mutation until much later.

The Racket group is here: https://groups.google.com/forum/#!forum/racket-users

I also know there are some youth education specific resources here: http://www.bootstrapworld.org/
And here: http://www.wescheme.org/

I might also recommend the Little Schemer, which presents and teaches recursive functional programming as if it were a book of puzzles. Realm of Racket is also pretty cool, though it does assume at least some programming knowledge already (it was written for first-year CS students), and you could try the early exercises in How To Design Programs as well (though I find them a bit long-winded and it may bore a younger programmer).

Good luck! I started programming at around that age, and I wish I'd had resources like Racket. If I'd discovered FP and Lisp then, I might've stayed with it instead of taking a break for ten years.
>Nim has made 4 syntax choices that might seem bizarre to a C++ programmer: 1. blocks by indentation instead of braces (aka "Off-Side Rule" syntax [0]); 2. Uniform Function Call Syntax [1][2]; 3. case-insensitivity for identifiers; and 4. dropping empty parens from a function call.

Most of those things are either totally accepted in the PL community (like "Uniform Function Call Syntax") or common and matter of taste, but nothing bad in themselves ("block indentation, paren-less function calls").

Case-insensitivity for identifiers WITH the underscore thing, though, is just plain bad, error prone, hampers auto-completion and IDE intelligence, and is plainly bat-shit crazy. Not to mention opening the stage for tons of bike shedding and holy style wars...

While there were languages with case-insensitivity in the past (especially pre-80s) nobody thinks that it was such a great idea in the first place, and pretty much everybody rejoiced when such features were abandoned.
Your iPhone Is Ruining Your Posture – And Your Mood
Millennial Startup Tramples Trademarked Software of Work-At-Home Mom
He doesn't say you won't see a Java bootloader because of unoptimized virtual calls, he says it's because the runtime is too big. CL: It also means that Java doesn’t “scale down” well to small embedded systems that can’t support a JIT, like a bootloader.
I am a novelty-seeker and I've turned to freelancing (in my case: data science). A lot of short, fast paced projects, everyone being different and requiring me to learn new things.
Seems like it's a classic case of "use it or lose it".

Not just with vision, but if you sit around all day you lose muscle, change fields of work and you may forget what you learned in school. Once you're inside, I can definitely see your eyes being affected by the difference in like as well as the fact that there probably aren't any objects more than 15 feet away for from you if you're at home since you're bounded by walls so there's no reason for you to be able to see further. This only gets made worse when staring into a screen that's anywhere from 6 inches to 2 get from our eyes.

Our bodies do a great job at optimizing. If for years in ends you're spending a majority of your time looking at objects that close, your body will adapt to it. Unfortunately, the byproduct of this seems so be the inability to see further distances.
I would look at the problem differently. I think this approach when you try to accept that you are "broken" or "ill" does not really help or motivate. I would consider myself, my brain, my subconsciousness as a one whole and try to interpret the signs it gives me. Like if you are bored by a project, that does not mean that you are a bad person who has problems with concentration or something. It might mean that it is not complex enough for you.

There is this theory that says that for every IQ level you have to find an appropriate occupation. If the occupation does not require the whole your potential, you feel bored. If it requires higher abstract capacities than you have, you feel overwhelmed. So the thing is to find your level.

On my previous job I switched projects every 6 months. At the beginning they all sounded so exciting, I didn't know anything about things that I would have to do on them, so I was so eager to start them and learn all the stuff. But after 3-4 months they were so boring, I was struggling so much and then I always inevitably landed in my boss office telling him that I cannot stand it anymore and I have to switch the project otherwise I have to leave the company. But the thing is this subconscious urge to do something different is much stronger than rational thoughts. I can fight for some time with myself and then I give up.

But then I decided to switch the whole industry where I was working. And now I am incredibly happy with that switch. Now I am on the same project for 8 months and it is nowhere any sings that I wanna jump to the next thing. It is very different here and the tasks I have, they require really whole my mental capacities leaving no place for boredom.

So what I wanted to say is that IT project != IT project. You can use the same programming language to build something that is not that complex in its nature and it will make you bored, or you can use it to solve a very complex problem and then you don't need to satisfy your thirst with new technology because the project itself is already demanding whole your mental abstract capacities.

So what I would do in your place, is that I would try to find an industry which is not only using new shiny tools but also builds something extremely complex. You have to find a complexity level appropriate for your. So take something that you think you are not capable of (something with complex math or physics or whatever) and see whether you can deal with that.
Https on GitHub Pages (GitHub.io) Open to MITM
And the length of this is exactly the reason why Johnny still can't encrypt and doesn't want to know how.

Getting things right, including disaster recovery, should be done correctly and silently by default.
Try private investigator.
tldr - more time outside in sunlight likely reduces myopia. kids these days don't want to go outside so you must force them.
OTOH, since the compilation model assumes a JIT, this means that purely “AOT” static compilers (which have no profile information, no knowledge of class loaders, etc) necessarily produce inferior code. It also means that Java doesn’t “scale down” well to small embedded systems that can’t support a JIT, like a bootloader.

This the quote. He talks about the JIT only, no runtime mentioned.
This article that is linked from there is quite fascinating to read:

http://www.moogmusic.com/legacy/pulling-music-out-thin-air-i...
Open source effort to bring open biomedical data together – anyone interested?
I feel like Swift reduces the runtime availability of dynamic dispatch by default... so for things like live programming or runtime hacking Swift is worse than Obj-C.

I envision a future similar to the "Smalltalk dream" where one can build apps live, with minimal recompilation and where dynamic dispatch should be the default. I think this scenario is less ideal for "systems programming" but for areas when one is snapping together UI components and data sources I think it's ideal. Perhaps someone here can come up with good counter examples why this isn't the case?

Finally, I think static dispatch, as is favored by Swift, tends to paint one into a corner down the road... but it's possible Swift has enough leeway so that this isn't the case?
I am interested. I know some tricks, but they are a bit unreliable.
The Tips and Tricks to Renting a Home
Buy them on craigslist.
You should really watch "A jit does that" video by cliff click, which is just excellent, but the brief answer is this:

Java has global knowledge of all loaded classes which implement an interface. So the easy answer is, for a given call site, only one class implements a given interface. Wonderful, devirtualize it (direct calls, inline if the methods are small.) As compared to c++, you skip the vtable memory load and the jump.

They're also smart enough that, even if multiple classes implement an interface, they count who gets called at a call site and speculatively devirtualize (ie devirtualize or inline with a guard check). This is a big piece of why they're so much faster than c++.

Imagine this situation: I have an interface for probability distributions, and that interface is implemented by eg gaussian, exponential, weibull, etc. At run time, I draw a million times from one of them, then I pick another by asking the user, draw a million times, etc. So there's a tight loop that bangs on that interface over and over. In c++, you cannot devirtualize that; each call to random->getRand() involves a vtable lookup and a jump. Java will notice that, eg, you picked gaussian so the call site will be devirtualized, skipping the vtable lookup and possibly the jump. Then, later, when the user says draw a million times from poisson, it will re-virtualize it, notice it's monomorphic with a different implementation, and revirtualize it. Inlining code based on usage, and being able to change that inlining at runtime is often a very effective performance improvement technique.

Now the ugly bit, and why the jvm is one hell of a piece of engineering, is you can load classes at any time during the life of a java program, so even if at start there is only one known class implementing a given interface that can change. Therefore, you have to be able to go to already generated code and revirtualize/deoptimize it. But this magic all just works.
Here's a good, if old, quick intro to some of the stuff the JVM does:

http://blog.headius.com/2008/05/power-of-jvm.html

Choice section:

The JVM is basically a dynamic language runtime. Because all calls in Java are virtual (meaning subclass methods of the same name and parameters always override parent class methods), and because new code can be loaded into the system at any time, the JVM must deal with nearly-dynamic call paths all the time. In order to make this perform, the JVM always runs code through an interpreter for a short time, very much like JRuby does. While interpreting, it gathers information about the calls being made, 'try' blocks that immediately wrap throws, null checks that never fail, and so on. And when it finally decides to JIT that bytecode into native machine code, it makes a bunch of guesses based on that profiled information; methods can be inlined, throws can be turned into jumps, null checks can be eliminated (with appropriate guards elsewhere)...on and on the list of optimizations goes (and I've heard from JVM engineers that they've only started to scratch the surface).

This is where the call site optimizations get their second boost. Because JRuby's and Groovy's call sites now move the target of the invocation much closer to the site where it's being invoked, the JVM can actually inline a dynamic call right into the calling method. Or in Groovy's case, it can inline much of the reflected call path, maybe right up to the actual target. So because Groovy has now added the same call site optimization we use in JRuby, it gets a double boost from both eliminating the dispatch overhead and making it easier for the JVM to optimize.

Of course there's a catch. Even if you call a given method on type A a thousand times, somewhere down the road you may get passed an instance of type B that extends and overrides methods from A. What happens if you've already inlined A's method when B comes along? Here again the JVM shines. Because the JVM is essentially a dynamic language runtime under the covers, it remains ever-vigilant, watching for exactly these sorts of events to happen. And here's the really cool part: when situations change, the JVM can deoptimize.

This is a crucial detail. Many other runtimes can only do their optimization once. C compilers must do it all ahead of time, during the build. Some allow you to profile your application and feed that into subsequent builds, but once you've released a piece of code it's essentially as optimized as it will ever get. Other VM-like systems like the CLR do have a JIT phase, but it happens early in execution (maybe before the system even starts executing) and doesn't ever happen again. The JVM's ability to deoptimize and return to interpretation gives it room to be optimistic...room to make ambitious guesses and gracefully fall back to a safe state, to try again later.
Hunter or farmer?

The hunter seeks new challenges, is less risk adverse, needs to be good at responding to the unknown and seeks the thrill of the pursuit and catch.

The farmer is more risk adverse and has the patience and diligence to gain satisfaction from seeing plans develop, mature and deliver results.

For me, while a definition of ADHD delivered by someone trained in identifying personality traits might be useful in developing a perspective on the strengths and weakness of one's personality, one might choose a more 'active' approach and look at the techniques that can help mitigate the most destructive aspects of the 'condition'.

Everyone is unique, we are somewhere on a bell curve and I don't believe that classification is particularly helpful, knowing one's self is not always any help in changing the status quo.

In terms of advice, I've never met anyone who has come to any harm from seeking talking therapy, I loved CBT and met a very nice councillor with a 'holistic' approach, trained in many diverse disciplines and with a very rounded and realistic angle, baby steps towards things you want to change.

Good Luck :)
You pay for Office 365 and you can get only a refund, you're a free user and you get a full free year.

Yap, this is how Microsoft creates loyal customers, punishing them
Weekend Work: SecApps Sec Tools AppStore
wow, I dreamed I was in 2015 with powerful pocket size computers showing flashing GUIs with multitouch support.
Darn.. I just woke up, I'm back in the 80's
Here's Stallman showing another awesome means of self sustinence:

https://youtu.be/I25UeVXrEHQ
What's to stop someone from diving head first down the stairs to speed up their descent?
He might somewhat tersely be conflating JIT and 'runtime'as whole - see the mention of classloaders but his meaning is clear, it's about size rather than performance. 'It also means' etc.
"Swift is a successor to both the C and Objective-C languages."

https://developer.apple.com/swift/

It is only a matter of trying and seeing what might still be missing in terms of toolchain.
I think I'll have a New Year's resolution to write quagmire in bug reports where I would have written spaghetti.

Might be harder to get the impact assessment to choose from: crash, error, incorrect function, botheration.

But I'll give it a go.
not awesome! will tell them :)
Awesome primer on probability distributions.
CPU Clocks and Clock Interrupts, and Their Effects on Schedulers
For therapeutic use the drug has to work reliably and predictably. For criminal use it only has to work sometimes.

Though I agree the whole thing sounds made up.
Sure, not everyone deals with stress in the same way, but an 'us vs. them' mentality isn't helpful. We're all capable of bad things, just like we're all capable of good things.

As for the article's agenda, perhaps it had one, but it appears to be an agenda backed up with facts, for example:

“Fewer than 5 percent of the 120,000 gun-related killings in the United States between 2001 and 2010 were perpetrated by people diagnosed with mental illness,”
That's not guaranteed to work in the face of crashes. The problem is that the directory update could get flushed to disk before the file data.

This is the fundamental problem: When you allow the OS (or the compiler, or the CPU) to re-order operations in the name of efficiency you lose control over intermediate states, and so you cannot guarantee that these intermediates states are consistent with respect to the semantics that you care about. And this is the even more fundamental problem: our entire programming methodology has revolved around describing what we want the computer to do rather than what we want to to achieve. Optimizations then have to reverse-engineer our instructions and make their best guesses as to what we really meant (e.g. "This is dead code. It cannot possibly affect the end result. Therefore it can be safely eliminated.) Sometimes (often?) those guesses are wrong. When they are, we typically only find out about it after the mismatch between our expectations and the computer's have manifested themselves in some undesirable (and often unrecoverable) way.
I have seen plenty of jobs where requirements are to go for novel solutions, get preliminary results and then pass on the job of following up to another dept. I wouldn't say your case is bad, but just not a good fit. Nevertheless there should be balance in everything, getting fired twice in short time may not be a good sign.
Serious question: How is the following quoted paragraph linked to ADHD?

Do you have a hard time transitioning? Are you late for
things because you a) can't accurately estimate time and
b) can't pull yourself away from the thing you're doing
at that moment even though you know you're going to be
late if you don't?

Sounds more like extreme focus. Isn't this the exact opposite of ADHD?
It bugged me that Sublime Text used to do these so-called atomic saves by default since it screwed with basic unix expectations like fstat and fseek meaningfully working (like a tail -f implementation could boil down to[0]). A concurrently running process using those calls would be off in lala-land as soon as the text file was modified and saved: it would never pick up any modifications, because it and the editor weren't even dealing with the same file any more.

[0] Here's follow(1) in my homemade PL:

#!/usr/bin/env imp

(when (not-eq? (length script-args) 1)
(write (sprintln "usage: " script-name " <path>") stderr)
(exit 1))

(let path (car script-args)
f (open path)
((proc (stat-then)
(let stat-now (stat f)
(seq (when (and? stat-then
(lt? (find 'size stat-now)
(find 'size stat-then)))
# The file was truncated. Read from the start.
(seek s-set 0 f))
(let bytes (read default-chunk f)
(seq (when bytes (print bytes))
(sleep 1000)
(recur stat-now))))))
FALSE))
See, this is why I compare it to Python's OSR syntax.

People react with these strong responses ("plainly bat-shit crazy"). People focus on inconveniences due to the limitations of limited tools ("I don't want to press spacebar FOUR TIMES at the start of EVERY line of code!"). People come up with elaborate worst-case hypotheticals ("What if you want to share your code with someone using a pastebin service that removes leading whitespace?") that just don't happen in practice.

In practice, it's just all upside and no downside. Now I don't need to remember whether it's `openHTTPConnection()`, `openHTTPconnection()`, `open_http_connection()`, `openHttpConnection()`, etc. If I can say it, I know how to type it.

Any ambiguous overloads (same name, same parameter types -- which again, really doesn't occur by accident in practice) will be reported & resolved at compile-time. There's no more mystery in this than there is in any function overloading scenario.

And in practice, it seems to cause the opposite of holy wars: People realize how pointless all those identifier case-wars are in the first place.

There's really not much more that I can say. "In my experience, there's no downside to this feature, only upside."
Cloudify 3.3 Released – NFV and Container Orchestration
Progressive Enhancement – Where to start?
That makes it sounds rarer and worse than it is. I think its more a choice than a medical disorder.

Its quite normal. If you work at home and have no family or other obligations that keeps you in sync, you tend to sleep in a bit longer than strictly necessary simply because you can. Naturally you go to bed later also. Now your day has become more than 24 hours. If you are allowed to do this every day, you get very out of sync with the rest of the world and occasionally line up with it again.
The advantage of -v is that you can see what is being extracted as it happens. This is useful if you have a tarball with thousands of small files, as otherwise it's hard to tell whether tar has got stuck or there are just a lot of files.
10 Years of Intel CPUs Compared
The ancient profession of netmaking will be completely relevant to high tech. Science fiction writers give up.
The "reader" function in Firefox works pretty well for that. I also found the contrast too low, especially on an older laptop. Switch to FF reader mode made a big difference.
Fair enough. I admit to not knowing when you would prefer statically checked mutable data structures to immutable ones except for a few cases (dynamic programming arrays, fast matrix libraries, memory constrained environments).

I did use the word "seems" there though. Its not really dismissal, I would indeed like to be enlightened. In projects where I can afford a GC, I'd always take the GCed option (in my case an overwhelming majority). Same for immutable data structures (use whenever they can be afforded). Are those bad heuristics? (Afforded here refers to performance/memory constraints only)

One thing that GCed languages don't solve very well is handling other more scarce resources (file handles, connections from a pool, etc). It seems that Rust managed to solve this nicely. If only it was possible to use GC for everything except those kinds of resources (perhaps it is?), that would be perfect.