skysight-inc/HackerNews huggingface dataset:
Hiring practices change drastically in five years. Not sure if srs
Yes, remember how Social Security didn't take seniors from the most impoverished age group to the least, and was completely unsustainable for 80 years?
Thanks for the comments!

I think editing by code is definitely better when you have 40 separate branches. What if your datasource (e.g. postgres instance) was a variable, and you could change this for each branch? Perhaps forking would also be useful, if there were specific charts you needed for each branch?

I think this is something that we're interested in building -- do you mind sending me an email at hn@davidh.su? Would love to chat more. Thanks!
Android Kotlin – Coroutines Listeners
Smiling can decrease odds of success against an opponent
HN is full of baronets arguing in favor of the modern social order -- because while they're not real aristocrats, they're not peasants.

Corporations function as de facto titles of nobility in the US, so crossing one is crossing social rank.
I don't know if you've done any home wiring, but in case you haven't and it seems like something you'd have to hire an electrician for, it really isn't. Swapping light fixtures, at least, is super easy, and so are things like installing dimmer switches. You can make a big difference in your home's lighting in a couple hours, and Google and Youtube can answer any questions you might have.

Just a vote of confidence from somebody who cares about not having shitty lighting at home :)
Employment is a voluntary transaction, entered into by both parties. One should always focus upon increasing their own skill set such that an employer may be able to make your life temporarily difficult, but your skills and value to an employer (or future employer) are such that they can't "ruin your life".
"By the time I’m done—adding more recovery scenarios, better logging, augmenting errors with more context, handle more edge cases—most of my boilerplate gets a lot more interesting. I did not realize that good boilerplate could be fertile ground for iteration."

This point makes sense, however I think I like to have my cake and eat it too. Java 8's stream constructions can be relatively terse, but if you need to switch back to a for loop, IntelliJ has nifty right-click menu items for doing so. I think the argument made by TFA is at least related to John Carmack's take on inlining vs. abstraction: http://number-none.com/blow/john_carmack_on_inlined_code.htm...
GOG.com summer sale
What exactly was the quality difference?
I assumed the title was about boilerplate in terms of some skeleton or framework you download. Turns out this is different from what youre talking about (verbosity). Its interesting that even in programming jargon we have two uses for the same term. They are not totally separate though. The repetitive, DRY violations eventually get abstracted into a framework, at which point the boilerplate becomes ok. And if its still too verbose, than another boiler may arose to encompass it.
> CEOs mint money because of social connections, not value to the business.

Sure, the CEOs are themselves often on the boards of other corporations. The incestuous nature of this top level is bordering on the absurd.
so you're saying that Pirate Joe is violation of trademark then?
Employment isn't voluntartly: there is strong economic coercion to be employed and high degrees of friction are introduced to make that coercion more effective.

Urbanization fundamentally has been engineered to create "wage slaves", who are basically modern sharecroppers (though the system has some extra steps).
Yes. By using higher level constructs, it is much easier to see what is going on in the code. If there are too many lines, it is much more difficult to understand a piece of code as a whole.
I don't really have a source, but it's common with protein powders.

They'll list 28 grams as a serving size with a scoop that has a line in it about 3/4 of the way up that represents 28 grams. Technically not misleading, but it's absolutely reasonable that people would assume 1 scoop = 1 serving size. The end result is that people go through more product.

If you watch professional bodybuilders who have to be very exacting about their intake, you'll see them tell you to always measure on the scale because you can't trust the scoop.
When social security started, they promised it would never take up more than 3% income tax. Today it is 15%. That is a 500% increase in taxes to support it, and it's only getting worse as lifespans increase and fertility rates decrease.

Bill Gates said that someday people will not have to work because of machines, but today we are just not yet at that level. Every able-bodied person should work if they need money. It's just not right for me to struggle paying my bills and 25% of my income to taxes so some other able bodied person can sit around doing nothing.
If you care about cities, apple's new campus sucks
I was going to write that I don't have a good pointer, but actually I think the idea is basically the "onion architecture" or "clean architecture". I don't recall if I watched all of this talk, but in general I like Brandon Rhodes' PyCon talks :

https://www.youtube.com/watch?v=DJtef410XaM

http://rhodesmill.org/brandon/slides/2014-07-pyohio/clean-ar...

I don't come from a Java background, but I think that many of these ideas originated in the Java community. They came to Python later (if at all), and it's a little funny to see Go struggling with the same thing.

I think I came at it from more of a functional programming perspective, and the style gradually converged with what people were thinking about OOP. I'm not actually of all the details about "clean architecture" and "onion architecture", but they are definitely related to dependency injection.

Basically all your effects and state can be instantiated on the "outside" in main() and passed INWARD. But I don't believe it necessarily has to be pure. I encapsulate all my state, but I don't encapsulate all my side effects, like printing to the screen.

Some people appeared to like this comment, which is somewhat related:

https://news.ycombinator.com/item?id=11841893

I'm not sure how much this will help, but here is 12K+ lines of code I wrote with zero globals:

https://github.com/oilshell/oil

The main directories to look at are core/ and osh/. The main program imports a lot of stuff and wires it together:

https://github.com/oilshell/oil/blob/master/bin/oil.py

(There is a bunch of surface messiness, but the architecture is sound.) I've also written even larger programs with zero globals.

Also, I believe that web frameworks are some of the worst offenders in terms of preventing you from using this style. I don't think I've seen a single web framework that made the handlers easily testable.

I think you may be fighting against the grain in some parts of the Python world using this style... I can do it in certain projects because I'm writing most of the code from scratch, and forking some dependencies.
Pirate Bay founder: We’ve lost the internet, it’s all about damage control now
I don't agree with many points.

1. Store uuids in a uuid field. Why starting the article with such a trivial finding that a text field is not optimal.

2. Use sequential uuids.

3. Several benchmarks have shown that the performace hit is minimal.

4. The only way to communicate with ids is to copy and paste them. Never try to memorize, talk about them or type them.
Is there a recorded talk somewhere that goes with this?
Doesn't sound like he really internalized the spirit of Aikido
Why didn't you ask to see details from HR? There's no transparency in their decision making - how do you know he was turned away for a good reason?
> Any time we write similar-looking code over and over, that’s considered boilerplate.

That's not what boilerplate code is, and DRY is not the way you get rid of boilerplate (the article claims it is a part of the solution).

boilerplate is a repeated preamble that's necessary and unchanging in order to get down to the business of actual logic.

An easy example of boilerplate would be include guards in a C/C++ header file, or 'use strict' in perl.

For example, the author says this:

> When I write Go, I noticed that my tweaks almost always go exactly where they naturally belong. My boilerplate doesn’t stay untouched!

If you're "touching your boilerplate" while writing code that affects the logic of your system, then it isn't boilerplate.
The author doesn't understand what boilerplate means.
Silicon Valley Isn’t the Only Out-Of-Touch Tech Bubble
Make our planet great again
Interesting take. I think everyone can find something in this with which to agree, so I don't think it's a particularly polarizing way of thinking, but I haven't seen terminology like this used to describe it before. I fall into the same psychological trap in C++ that the author falls into with Python: the "if this is over here instead it's more [elegant/right/concise/impressive/less boilerplatey]". Unfortunately, I find it too tempting to value beauty and elegance (and often masking real weight and complexity) over the in-your-face 'rawness' of simple loops, branches and so on. In Go this is harder to do in general, so you only try for so long before you learn not to fight it. This comment really spoke to me:

> Maybe this is subjective but I posit that the code’s shape looks more like what it is.

Indentation isn't merely stylistic or syntactic, but it tells us useful things about code at these lower levels. A more complex code shape should convey more complex logic, and we should want that complexity apparent to us...at least sometimes. It looks great to have a nice, terse one-liner, but visually flattening possible control flow paths feels really nasty.
Nice they have a JDBC driver... makes it a lot easier to hook into. After looking at all the C++ jobs on Bloomberg's website, makes sense the schema format looks C++ish.
Excellent post, write ups like this are the reason I keep coming here.

What about the hi/lo algorithm as a middle ground?

https://vladmihalcea.com/2014/06/23/the-hilo-algorithm/

In short, and I hope I don't oversimplify, each "shard" or "cluster" in the database gets a "block" of ids it can then go and assign on their own, the sequential "atomic" increase happens only once per hi "block", lowering the contention.

This gives you nice integers, incremental-ish most of the time.

I like the notion of integers internally and UIID (as integers of course! I would have never saved one as a varchar, I swear! ok, I was a noob... I deserve to be shamed)

Great post all in all!
That is why I said you need practice writing in this style. It's quite easy to overdo it and end up with a mess.

I don't think it has to an all-or-nothing thing. I generally encapsulate all my state, but not all side effects, like printing to the screen.

And yes I believe logging should just be a free function. I think configuration of loggers is overrated. But if you need to use a global for that configuration, so be it.

Functions don't expose any implementation details -- they expose the state they modify and the side effects they produce.

I don't quite understand your last sentence. Dependency injection IS popular and that is what I am advocating and what this post on Go is advocating. It's perhaps not as popular in Go and Python as it is in Java, and perhaps even some corners of the C++ world.
As I stated in another reply. I don't actually want to count bits at all. Counting is just the simplest thing I could do with the bits in the test case. Turning a stream of bytes into a stream of bits can be quite useful.
What you're describing here would require the company to be able to access their clients servers and data.

I don't know of any server provider (bare metal or cloud) that forces users to allow the company full access to their data (outside of managed providers were you voluntarily give this up , as you're paying them to fully manage your server)
I iterate code like he does, then when it gets to where it's doing what I want it to do, I refactor it to make it more readable even if it reduces iterability. After the initial phase of writing the code, going back and forth, etc, the code is going to be read many more times than edited, if in the future it needs to be edited again, the future editor can refactor the nice looking code into whatever shape, and the important thing was that future editor understood my code in the first place, and I hope that future editor, when done editing, will refactor the code into being easily read for the next person, too.
USB Mess? Download from http://www.usb.org/developers/docs/ as a zip file. Are you thinking IEEE1394/Firewire which has a significant cost?
Libsodium Quick Reference: Similarly-Named Functions and Their Use-Cases
I would say that logging and memory allocation are special cases. They're things that need to be done by literally ALL your code.

I agree it would be completely silly to change the signatures for a bunch of methods just to print something.

But sometimes you absolutely DO want to inject dependencies for things. The Lua VM is parameterized by the allocator it uses, which is useful in practice.

And I would distinguish between logging and program output. Logging can be an exception, because it doesn't need to tested. You probably don't want your unit tests to fail if your debug logs change.

But maybe in some situations you have some really critical logging, and you want to test that part. Then you can parameterize that code by the logger.

Although honestly I would usually just write a shell scripts and invoke "diff".

So yeah I don't agree with absolutely pure DI or pure functional programming. But I definitely think the ideas there will help you structure better programs.
Another Newbie on the Internet
Fast. We use connect directly to your SQL database (mongo coming soon) so that's the perf bottleneck. Currently no query timeout -- if you host it yourself, the server is also async, so timeouts won't be an issue. Caching behind the scenes is something we'll build over the next month.

I think that Chartio and Mode are very good answering questions, and exploring data. If your problem is "what is our CAGR since 2015", Chartio is good for that. Mode, I think, is more similar to us, and certainly better for data analysis. I think, however, that we are more customizable than Mode -- imagine writing a search box in Mode, for example, in order to drill in deep on a certain customer's orders.

I think we're more about building apps that would be rote coding otherwise (e.g. building a CRUD app to manage orders), or empowering non-engineers to build and maintain these apps themselves. Instead of hiring more engineers, what if you made everybody in your company able to quickly build simple software? I think Excel has been very empowering, and we want to do the same.
Reading through their VLDB paper [1], Comdb2 appears to be a moderately scalable (up to dozens of nodes (?)) RDBMS with a strong emphasis on consistency and availability. Benchmarks show numbers comparable to Percona XtraDB (MySQL with a different storage engine), at ~2,000 writes/s and 2,000,000 reads/s against a 6 node server cluster. High availability and global sequencing is provided by using GPS clocks, similar to Spanner/Truetime.

Schema changes happen lazily, with old rows being rewritten on the next update, and a background job doing bulk rewriting.

Scalability: "While reads scale in a nearly linear manner as cluster size increases, writes have a more conservative level of scaling with an absolute limit. The offloading of portions of work (essentially all the WHERE clause predicate evaluations) across the cluster does help scale writes beyond what a single machine can do. Ultimately, this architecture does saturate on a single machine’s ability to process the low level bplogs."

This doesn't provide the horizontal scaling that Spanner does, CockroachDB aims at, or FoundationDB presumably has.

[1]: http://www.vldb.org/pvldb/vol9/p1377-scotti.pdf
That's true for pcie 2. Pcie 3 is 128/130b encoding, so it's much, much more efficient.
It's always bad.
The second line makes you understand with a glance what it does because it is declarative and explains what is doing instead of how.
The go code is awful (personal opinion, although I hope it is widely accepted), much more verbose and it opens you up to a whole series of errors that are just impossible in the python version.
Boilerplate code by definition is just duplication and it is always bad because opens you up to bugs in a specific part of the boilerplate while you can't have any bug at all in any boilerplate if you don't have any of it.
Honestly I can't really see how anyone can prefer code that is more verbose and bug-prone to code that is more concise, clear and with less bugs.
It is the bottleneck. This is why Nvidia invented nvlink.
Yes, flags vs. config files in Unix are a classic example of dependency injection vs. side effects, but at the process level rather than the programming language level.

At Google pretty much all server configuration is done with flags. Binaries can and do have thousands of flags. And I view that as a much better solution than a config file that is searched for.

The idea is that modular units like processes and functions don't "search for configuration", they just accept parameters, and led the higher level application configure them. Then the code becomes very straightforward to read and debug.
There's a game on the app store called Doodle God with the same concept

Doodle God™ by JoyBits Ltd.
https://appsto.re/au/HwWBw.i

Doodle God™ Free by JoyBits Ltd.
https://appsto.re/au/tNEDz.i

Has IAPs and isn't the most fun game on the app store, but decent enough.
Somewhat annoying you have to copy data to nodes manually:

copycomdb2 mptest-1.comdb2.example.com:${HOME}/db/testdb.lrl

This sort of stuff is why I loved RethinkDB. They handled all these complexity details for you.
I had a manager who was consistently underpaying me, significantly. When I quit in disgust, he threatened me that he'd make sure I never got another job. He had been milking my success to get lots of bonuses and raises for himself, even though I did absolutely all of the work and he just "managed" (which meant, ignored me completely). So he wasn't happy that I was quitting, and though he could bully me. Luckily for me, I didn't have to use him as a reference, as 2 other PMs agreed to vouch for me.

So, just because a guy has a bad reference it does not mean that he's necessarily bad.
Apple makes major podcast updates
I've worked at midsize "non-engineering" companies that do boring stuff like logistics where they wrote their own RDBMS and even virtual machines for legacy hardware.

It's not that uncommon especially if you've been around a long time.
<<
or FoundationDB presumably has
>>

You mean FaunaDB?
When I said "groceries," I was referring to food. I wouldn't be happy having to buy 100% of my food at Trader Joe's.
what do you think makes glenn goulds recordings so great?
>Houzz is interesting because all the photos are of homes with limitless budgets.

I don't think this is true. There are tons of Ikea kitchens in Houzz. We got a lot of inspiration from Houzz when renovating our apartment. I really like that it has a mix of high-end and Ikea, because many times those high-end ideas can be implemented with cheaper alternatives.
Fwiw, the main motivation for the separation was for the IDE. It got easily confused mixing code and markup so we opted to keep them apart.
SEO Company in Bangalore – Brandstory
Researchers decipher how faces are encoded in the brain [pdf]
For reasons that are appropriate, I will not be taken seriously. The idea is only 1/3 software centric and can't be properly tested with prototype/at smaller scale. Also, no money. It's not that complex and I'm sure someone with the right circumstances will make the connection eventually.
A climate solution where all sides can win
Iteration: A Gentle Introduction to Functional Programming
There are plenty of examples of individual companies (or groups of companies) getting too much monopolistic (or oligopolistic) power and doing just that or similar. You could look at at the Phoebus Cartel of lightbulb manufactures [1], the Bell System monopoly [2], or in transportation the GM Streetcar conspiracy [3].

Due to Uber's network effects you could say they'd have even greater power to change prices dramatically. Let's say Uber became the dominant transportation network in a particular geography and then trebled prices. Any new competitor has to both lure riders and drivers from Uber. Riders, sure they can be lured by cheaper travel but drivers want to earn the most money. Uber could simply double how much they paid drivers. All the existing drivers (and any new drivers) would rather work for Uber and get paid more. In fact they would have a vested interest in seeing the competitor fail.

1: https://en.wikipedia.org/wiki/Phoebus_cartel

2: https://en.wikipedia.org/wiki/Bell_System#Nationwide_monopol...

3: https://en.wikipedia.org/wiki/General_Motors_streetcar_consp...
The study was by a psychologist. Psychology is not a science anymore than astrology is.
In my current project, in ms sql server, I have guid PK with unclustered index and clustered index on another field filled with current time stamp on insert.

What do you think about such setup?
DHH Against “Exponential Growth Ideology”
> Your editor's inner state, for instance, is not visible to other applications, so you need to come up with your own whole programming scheme.

> Same with your window manager.

> You don't need to build your own programming language for Acme, because Acme's state is visible as a filesystem.

I don't see how it's good programming practice to expose your internal state to direct read/write access from other programs. It seems to violate basic encapsulation principles.

Your quotes are making me think of some really important takeaways from the Longhorn disaster with WinFS, detailed in a recent submission[1]:

> More profoundly, Bill’s vision of an ecosystem of applications that all store and share their data in this relational store is in direct conflict with how applications build their data models. While some desktop applications (and almost all internal IT-written ones) use relational stores for their internal data model, they do not want to expose those data models for unmonitored read and write by other applications. I detailed some of the fundamental reasons in the post referenced above, Leaky by Design.[2]

Solutions like this... "what if application state were like a relational data store, or hierarchical FS, that other programs can access", sounds great as a fun programming exercise, but it isn't often how people actually want to design applications.

[1] https://hackernoon.com/what-really-happened-with-vista-4ca7f...
[2] https://hackernoon.com/leaky-by-design-7b423142ece0
FoundationDB was the proto-CockroachDB (or rather, CockroachDB is essentially a re-attempt at building FoundationDB). It was an early attempt at building a NewSQL database. (NewSQL per se, i.e. not counting parallel databases from the pre-NoSQL age, like Gamma [1], Volcano [2] and Grace [3], which share many of the same design principles.)

FoundationDB was acquhired by Apple, but its failure is generally attributed to a poorly-performing SQL layer: https://www.voltdb.com/blog/2015/04/01/foundationdbs-lesson-...

[1] http://pages.cs.wisc.edu/~dewitt/includes/paralleldb/ieee90....

[2] https://paperhub.s3.amazonaws.com/dace52a42c07f7f8348b08dc2b...

[3] https://pdfs.semanticscholar.org/a7f4/e4e6166dc683e7fa7d5b9e...
5 Smart Ways to Market Yourself as a Techpreneur – The Growth Bar