skysight-inc/HackerNews huggingface dataset:
I still feel the REPL-like environment in Jupyter is more suitable for building an idea, while RMarkdown is better for publishing it.
Vest but not release simply means that you've earned the right to those shares (vested), but that you don't actually have ownership of the shares (released) until some later time or event triggers the release.
>The greatest gains in poverty reduction have come in China and India, which, together, have lifted just short of 1 billion people out of poverty.

As per wikipedia[1],still a long way to go

world had 872.3 million people below the new poverty line, of which 179.6 million people lived in India. In other words, India with 17.5% of total world's population, had 20.6% share of world's poorest in 2011

[1]https://en.wikipedia.org/wiki/Poverty_in_India
720 npm packages..........................................
alias is free
I'm suspicious because anything slightly critical of AWS or their terminology has been heavily downvoted in this thread.
http://fuscus.li Does free-floating windows. But, it's quite pre-alpha.
I think I'd have to trust google to respect that. :-P
Thank you for your civility :). The word 'secure' is subjective and thus always a matter of opinion (since obviously nothing is truly secure).

LDAP is insecure: it has a long history of serious problems. (for example, https://www.cvedetails.com/vulnerability-list/vendor_id-439/... ) (389ds and IPA are all based on the slapd OpenLDAP code.)

0) it's enormous: both as an implemented application and as a protocol and specification. Complexity is the enemy of security.

1) it widens your network footprint and isn't hardened against modern attacks (all LDAP directories that I'm aware of also have a regrettable history a la bugtraq/cert). (even without bringing krb5 into the picture)

2) it is complex and allows schema/ACL changes to expose attributes in non-obvious ways

3) no commercially available LDAP implementation natively encrypts all data

4) ouch, LDAP injection (https://www.owasp.org/index.php/LDAP_injection)

5) A centrally managed directory represents a very rich target for the secrets it contains

6) particularly when used as an authentication backend, it also presents a nice DoS target. (I have personal experience from a previous life..) :(

7) An LDAP server exposed to a LAN is rapidly (today) approaching being exposed to the Internet as VPN connections join multiple clouds and formerly internal datacenters, for anything but the tiniest of network footprints.

8) Most of the interlocking services, such as KRB5, have a sordid history of really bad root-level vulns.(https://www.cvedetails.com/vulnerability-list/vendor_id-42/p...)

Obviously many of these concerns can be somewhat mitigated but my strong personal opinion is that the size and complexity of LDAP makes it its own worst enemy. With that said, there's no real replacement for it, right?

With regards to things like SSO and SAML2, oauth (which also has its own share of problems due to the same problems of size and complexity) is beginning to make the need for an enterprise-wide directory moot, but this will obviously take time.

Not to mention - implementation to integrate with something like FreeIPA or similar is just unmitigated pain, both up front (i.e., if you want to run it somewhere like AWS without control over reverse DNS) or on each node (I've written PAM modules before and I still think making PAM changes is a big pain and not without significant risk.)
"The new rule “very definitely is something that would work well for somebody who doesn’t need it, a company with a really big brand name,” said ralliBox founder David Kneusel. “But it is not something that is startup-oriented.”"

Actually I think it is startup friendly. It allows a startup with a strong balance sheet to get funding from average people (non-accredited investors) without the burden of being fully public.

Think consumer facing or businesses specific to a locale, especially ones that have a fan base that may want to invest. Not the sexiest to VCs, and not wanting to deal with going fully Public, but still could have a mutually beneficial relationship with investors.

It just so happens that it's not that friendly to the traditional "tech startup" that we think of, one that takes the capital and guidance of a VC to launch into profitably.

That being said, there still is a fair deal of work that goes into compliance, audits, and finding investors for Reg A+. Gven how rigged a standard IPO seems between the investing bank's cut and Friends and Family rounds, I'd say Reg A+ is a welcomed addition to funding options.
I'm cringing.
I'm cringing at that entire paragraph.
Vive is not designed for seated use. You really need to use it in 3D space to appreciate it.
Akamai failed
The problem with Oculus Touch (they're sweet-looking controllers, and I hope Valve steals that type of idea) is that it doesn't ship with every Rift. For Vive owners, a developer can assume that they all have room-scale positional tracking and motion controllers. With Rift, if a developer wants to write Touch support, they're shooting for a fraction of an already-tiny market. I mean, the Rift could fail before Touch gains any traction (hope not). Why would a developer take the chance?

Of course, Oculus' salvation is that they're owned by Facebook, so they'll never run out of money to throw at the problem.
Up in the Air (2015)
> I think it adds to the complexity of language.

How so? What makes Erlang more functional? And how is Erlang simpler for you?

A big part of the renaissance in programming languages come from developers leveraging rock solid VMs such as BEAM and JVM. It enables developers to have the expressiveness of dynamic languages and without sacrificing performance or scalability later down the road.

In the case of Elixir, many feel that it adds some innovative language features like the pipe ("|>") operator and metaprogramming facilities that ease many of the pain points with Erlang. I'm not an expert in Erlang but there are quite a few notable Erlang developers that enthusiastically support Elixir (including some nice words from Joe Armstrong).

I'm not arguing with you but curious about your thoughts. Looking forward to the next installments in your series.
The latter version doesn't sound so bad, because the USS is a dead giveaway "this here is the name of a ship." The former, on the other hand, would seem rather strange. It would sound a bit like this:

> General Patton has never seen combat, nor would she be of much practical military use.

(given Gen. Patton is a widely known character thus those familiar know he's a "he")
Mysterious death of software pioneer Ian Murdock ruled suicide
Same. And I also do this with distros, window managers, etc. I find myself bouncing back and forth between convenience and simplicity - the grass is always greener.
you're a terrible person
> I suspect this attitude has something to do with the human fallibilities of sunk cost and cognitive dissonance: if you’ve already spent hours and maybe some cash on a particular activity, you might keep playing because you don’t want that effort to “go to waste,” and then you might imbue that activity with all sorts of heavy meaning and nobility to assure yourself that your time was well spent.

Many new freemium games now are trying to copy Clash of Clans with unnecessary resource management mechanics a low-effort PvP mode. Makes sense on paper. However, I've read a lot of discussion about how people are getting bored of these types of games, especially now that they are aware of the time-sink nature of the games after having experienced it (and consumed by it) once before.

It would not surprise me if there is a shift from Clash-likes. (indeed, the Hero-collectathons have been surprisingly popular lately...)
That's like saying you drop a modern human in the middle of the jungle, and tell em to survive for a week. I'm sure they'll "learn", or die trying but is that really a good way to do it?!
Have you seen the HoloLens by Microsoft? They've developed a custom silicon chip to off-board all the SLAM processing, and they use that for realtime localisation. Current SLAM techniques are absolutely fast enough for this, VR manufacturers just haven't gotten on board yet.
> why is there a group of people that [want to wrap everything] in HTML/CSS/JS

I believe you already know the answer to your own question, because to be honest I think the answer is pretty obvious; but in case you are actually curious about the answer here is what I think (mostly sarcasm, don't expect much):

The majority of people making these applications are web developers who are frustrated by the difficulty of learning one or more of the popular GUI libraries available in the market (Cocoa, QT, GTK, etc), they found Node-Webkit and then Electron and realized that they could target desktop users using the same stack they have been using so far (HTML + CSS + JavaScript). Since they are web developers and many of them were originally designers, it is makes sense to think that they can make shiny websites to attract people into trying their projects.

I think most of these programmers just want to show up, try this new Electron thing, and get acknowledged by other people. I don't think they believe their applications are actually good because it is obvious that they are not (as in this case). As much as I hate this trend of web applications disguising themselves as (native) desktop application I have to agree that Electron have allowed some people to... Hmmm, you know what? I don't think Electron has allowed anyone (with the exception of GitHub) to accomplish anything, fuck that trend.
<sarcasm> I am so happy that congress has time for this extraordinarily important bill. It's definitely more important that we don't allow these words to continue to be used, than to appoint a new judge to the Supreme Court. </sarcasm>

When do we declare a state of idiocracy?
This belongs into every statistics class:

* Use guesstimated data from a time when the basis for the data was not even established ("money" in 1820, when lots of people where still exchanging goods or labor).

* Just go back far enough that you can claim the "overall trend is positive". Ten years increased poverty levels in the US? Stop whining, it is still better than 56 years ago!

* Expand the scope of data collection: Just look how well China and India did. Never mind that their definition of "poverty level" is not even comparable to most other countries.

* Correlation equals causation: In a time when, according to some metric, global poverty decreased, so did infant mortality and infectious diseases (using data going back to 1900, again). School enrollment increased (now back to 1820 again!)

* Bury a controversial point at the very end:

"The World Bank cautions that these gains
have been unequal across countries, and the
OECD reports that in many cases, the growth
that allowed for reduced poverty was
accompanied by increasing income inequality.

Still, the World Bank has set a goal of
eliminating extreme poverty, currently
defined as living on $1.90 a day, by 2030.
That kind of goal would have been unthinkable
in 1950, to say nothing of a century earlier."

The author should try to live on that $1.90 a day in every country for a month and then make this same "all is good" statement again, with a straight face.
In my experience, terminals like xterm and rxvt ran extremely efficiently on machines 23 years ago, like, oh, a 66 MHz 486 DX2 with 8 Mb RAM. I can't say that I ever had a complaint with the speed of scrolling, or rendering of characters, or general responsiveness.
Gordon, Zettelmeyer, Bhargava, and Chapsky "found some evidence that PSA’s as controls would lead an advertiser to draw the incorrect conclusion about the true lift of an ad campaign."[1]

[1] You can't tell me not to cite! ;)
> we've hit the end of ad-supported startups.

How about ad-supported, one-or-two-person operations with good traffic? Is advertising still a viable revenue model for something like that?
This was demoed at Google I/O for Project Tango, featuring furniture from WayFair among others. It's not true VR but AR, which actually works better for this application. Until consumer project tango hardware has shipped in quantity, though, it won't get past the demo stage.

The great thing about project tango is that since it has accurate depth sensing and builds a 3D model of the space, furniture placed is accurate to scale. Demo video: https://www.youtube.com/watch?v=2gYwc6nS7qs
At first it was extremely tedious to maintain the ratio... You'd be surprised at what macros / micros make up certain foods. After a few months, my SO began following keto with me so we ended up completely reworking our recipes and grocery accordingly. Most restaurants or social events will have keto friendly foods, and if not, it's pretty easy to just take the bun off of a loaded burger :P

This was done under doctor supervision. Monthly checkups (standard without keto) w/ bimonthly blood work (done just for keto). Completely healthy throughout. There were a few times protein slipped up a bit high, but that was my fault. Cholesterol oddly fell to extremely healthy levels.

Couple important things to note about maintaining keto long term: Maintain majority fat intake; preferably healthy fats, although it didn't really seem to make much of a difference, at least in the short term. MCT oil and butter is your best friend. You'll want to watch your micros and supplement accordingly; there are a lot of micros that you will not get if you do not eat fruit, certain veggies, etc...

Ignore grammar. On mobile.

EDIT: I would stronly suggest doing this under doctor supervision.
The only band that mattered.
Unless you specifically tell the JVM otherwise using the -Xmx flag.

See: https://docs.oracle.com/cd/E13150_01/jrockit_jvm/jrockit/jrd...
While I agree with you that urxvt is a great tool, I disagree with the suggestion that the terminal is "a solved problem" (or that vim is perfection). There is a lot of room for innovation, though not necessarily in the direction that Go Terminal is going.
How to Write a Follow-Up Sales Email That Doesn’t Suck:
Comprehend (YC W11) hiring Sr. Software Engineers to speed dev of new medicines
But I like them.
ABF, Always Be Failing (just a little bit).
0. I believe that both LDAP and AD have complex models (well, arguably less complex than Vines/NDS/x.500/etc if you go back that far) and they're certainly more secure than NIS/NIS+ based on historical vulns, but I find it hard to argue that they're 'secure' based on their long and sordid history of vulns ( https://www.cvedetails.com/vulnerability-list/vendor_id-439/... )

0a. and, well, I wouldn't want to connect boxes to LDAP because I prefer to log into my boxes, even when LDAP is unavailable, the VPN is down, etc. but, nscd et al.. caching doesn't work either on an autoscaled box in the cloud, nor would I want to expose my enterprise directory infrastructure to my VPC. I also don't want to introduce a new PAM and NSS configuration on every single box (with separate layering for different boxes into different projects etc) and introduce yet another avenue for mistakes and compromise... was that required, requisite, or optional? Ergo, obsolete. :) (imo)

1. (btw, We don't do server authentication. That is a key difference between a directory and Userify. We only distribute keys. The servers themselves authenticate their own users with Userify just like with the traditional model, whereas with a directory the LDAP/AD server itself performs every authentication.)

2. We also recommend purchasing and running Userify Enterprise locked down locally to your VPC/LAN, and our larger customers tend to prefer that as well (especially when connected to LDAP w/ the same disconnected model we designed into our core product). We also offer a free cloud-based edition for unlimited use because we're nice like that.

3. We're paranoid, just like you: we go through bi-monthly independent penetration tests, we encrypt all data w/ NaCl, we avoid using passwords where possible and has with bcrypt elsewhere, and we're hardened against XSS, CSRF, and any sort of injection. The shim source is available here: https://github.com/userify/shim (see https://userify.com/faq/ for more on the security stuff we do and we're open to more ideas) and, please, find our vulnerabilities. We'll pay you for them. https://support.userify.com/solution/articles/14000036246-fi... Sometimes even our larger partners don't do that unfortunately.. ( https://github.com/aws/aws-codedeploy-agent/issues/30 )

But, seriously, people who are happy with their current solution should probably stick with it. I don't expect to convince you to take another look, and I do agree that there are good arguments to be made that LDAP/AD is neither insecure nor obsolete. I just disagree with (most of) those arguments. ;)

note:

AD/LDAP connectivity in Userify: you can still authenticate natively via LDAP/AD, while Userify provides a user-friendly dashboard for key management for your teams. A particularly cool demo: remove or disable an account in Windows AD and seconds later watch all of the SSH sessions on all of the servers in all of the projects terminate. It's very slick.. and that's another thing that LDAP/AD directory authenticated solutions can't do.
https://news.ycombinator.com/item?id=12042252
Thank you - needed saying.
That's changing now, thankfully. Most people at the company I work for use Clojure every day.
Believe me, they have no interest in foreigners. All this is by Chinese for Chinese.
Why? It's an interesting article with actual photos; several steps above blogspam.
You, me, and maybe 6 more people :P
I love that idea. Map -> Reduce of unit tests.
Thats a pretty good way to put it. It's like the difference between a slightly better display and being in another world
Same problem on IE 10.
Why not linking to PDF directly then?
Can someone summarize the results? Should I continue using my SSD, or no?

:-)
An SQL injection issue right there.

Edit: to be fair the variable proj_id sounds like it's not taken from untrusted input, but nevertheless a bad idea.
Well there's Slack and VS Code just off the top of my head
Wireworld
Isn't tangentially just another word for "what aboutism"?

Have you ever tried reading the Chinese media before? It is a step above North Korea's media, but still incredibly twisted.
Physical cryptographic tokens meet this requirement: something you have-possession of the token itself-and something you know-the PIN to operate it.
I use both Python and Erlang. Python is to get small stuff done quickly language for me. And "small" doesn't have to be just a demo or hello_world example, it can be a whole full back-end of a business.

(And btw when I say Erlang I also mean Elixir, they both share the same VM so most things apply to both).

But Erlang is a the secret sauce (so to speak) for a high concurrency fault tolerant backend. "Fault tolerant" should probably go first. The reason is the observation that the higher the concurrency or complexity in the system, the higher the need for fault tolerance. If you only serve 10 connections and the backend segfaults, 10 clients have lost connectivity, you get 10 angry phone calls. If you serve 1M connections and your backend segfaults, you get 1M phone calls. Exaggerating here of course to get the idea across. But this is not just a marketing gimmick, this translates to money in the pocket in operational costs. Some subsystem crashes and restarts? Fine, let it do that if it is 4am, no need to wake people up, will fix in the morning. I've heard of stories of subsystems crashing and restarting for years with the main service staying up.

The lack of centralized state might seem minor but unless you have been debugging a shared memory systems with locks, threads and manual memory allocations, with classes that have pages of attributes defined, and trying to understand why it crashes on Wednesdays only at customer A's site, it is easy to miss the benefit. This comes through using small lightweight processes with an isolated heap and also using functional constructs.

Then in general, the ability to reason about concurrency using OTP constructs (Erlang's standard library) and processes is like going from Assembly to C in terms of distributed and concurrent systems. Can express ideas at a higher level. This means having less code to look through and maintain.

There are other niceties like good garbage collection performance, awesome tracing and hot code loading capability (used this a few times, so started to appreciate it more now).

Now, individually all of those features can probably be found in other systems and frameworks, but they are just not integrated or not quite there -- Java has code loading but it is not the same. Can always spawn an OS process to get fault tolerance, but can only spawn so many before system falls down, Go has goroutines but they also share memory, so fault tolerance is not there. Other languages have garbage collection, but most still have to stop the world sometimes and so on.
Actually, let me unflip that table.

I am desperate for someone to come along and realize that the current terminal interface is a perpetual train wreck, and that if we can break compatibility but end up with something better we should.

Consider for a moment what a monumental task it is to make a simple ncurses menu and status bar in bash script. Consider for a second how trivial that could be made if each command line entry were a small flexible webview.

Imagine if you typed netstat and it showed the results, but there was also a field where you could key in text narrowing queries as part of the standard presentation for all very long input. No more appealing to grep or more and losing context or blasting your scrollback buffer.

Consider for a moment if we could move away from trivial line interfaces for SSH and towards a protocol that actually handles sessions and works over SSL in every conceivable network environment. Hell, most people I know have migrated to mosh and only type ssh when they're provisioning fresh cloud instances (usually to get mosh on there as fast as humanly possible).

The entire idea that "text is a superior interface" is correct as an input mechanism, but not necessarily as a data presentation mechanism. HTML and some basic es2015/typescript/whatever isn't just flat out better than bash for this sort of thing, but it flows from a long history of tools like tcl/tk trying to make the shell a more efficient and effective place to visualize trivial data.

I've been using terminals since 80 characters was a luxury and amber was the fancy new color, and for at least 20 of those years I've been hoping we'll see something that keeps the composability of shell scripting but introduces a non-line oriented protocol that could also offer presentation logic when appropriate.

We could preserve all of that if we just pretend all existing shell commands return a (forgive the templating syntax, it'll be understandable by a wide audience) Map<Stream<Text>> where {'stdout': <stdout>} and additional data can be offered around that with trivial API additions.

Please, let's not pretend we'd not benefit massively from richer tooling here.