wting

FYI the new website is down (http://new.reddit.com) but the old website is still up (http://old.reddit.com).

As others have stated, http://status.reddit.com will display uptime stats.

For those that use vim, gundo.vim visualizes the "undo-tree" and allows you to preview / jump to any revision: https://github.com/sjl/gundo.vim

Excel has been dryly noted as the most popular functional programming language before: https://www.infoworld.com/article/3033912/functional-languag...

In Excel you can't modify existing state in a cell, but only transform and output the results in a new cell.

Due Diligence

I was a professional poker player for ~5 years, and my wife—who has a much lower risk tolerance—asked that I never share variance with her since it causes quite a bit of anxiety.

My daily numbers were in tens of thousands range rather than $11M, but the effect was the same.

>ECC is recommended but many people, myself included, have run many stable years without ECC.

zfs requires ECC[0][1], do not skimp on this.

I ran many zfs pools for >8 years without issues until silent memory corruption happened to me, and now I can't access my data anymore (zfs won't let me mount a zpool that fails scrub checks).

0: Oracle (and previously Sun) documentation recommends ECC to prevent silent corruption:

>Consider using ECC memory to protect against memory corruption. Silent memory corruption can potentially damage your data.

https://docs.oracle.com/cd/E23824_01/html/821-1448/zfspools-...

1: https://louwrentius.com/please-use-zfs-with-ecc-memory.html

If you're looking for an off the shelf solution, I turned an old Android phone into a baby monitor for keeping track of crying when I'm on the other side of the house. There's plenty of baby monitoring apps that do anomalous noise detection and raises an alert.

I'm thankful for Hacker News and its community.

I am successful largely in part because of the community and its discourse. I was introduced to the growth mentality when browsing this site back in 2010, and astonished by how open and humble people approached their failures.

This resonated with a lot of my personal struggles. However taking on a growth mindset put me on the right course and helped me take on increasingly larger scope and responsibilities at work, and also improved my relationships with family and friends.

Fortunately I'm now in a position where I can help shape culture, and pushing for learning and open mindedness has been an underlying principle for many of my actions.

I believe grandparent was referring to proactive raises.

Reactive counter offer raises typically don't work because the employee's mind has been made up to leave. Compensation is usually only part of why someone decided to leave.

I fixed this problem for myself by automatically pulling down changes in the background upon opening a new terminal.

Since checking on every terminal open is unnecessary, I check on a probabilistic basis based on how often the backing git repo changes (0.5% - 3%, different repos for vim, dotfiles, configs).

Time based SLOs definitely have their limitations, but in this instance isn't it fairly easy to redefine the SLO in terms of requests rather than time?

>A lack of typing puts an upper bound on the complexity of the code that effectively limits the line-count and relegates the language to 'glue' status.

I disagree. I work(ed) at two of the more famous Python shops: Yelp and Reddit. These companies have many millions lines of Python code combined. Also FB was mostly a PHP shop until they started Hack in 2014, 2 years after they IPO'ed.

Testing and monitoring can be used to combat type errors. Runtime type errors still happen occasionally, but honestly these are some of the easiest bugs to squash.

I think you might be conflating static typing with strong typing when you infer that Python has "lack of typing." Python has a dynamic, but strong type system.

I've coded professionally in many other languages (C, Java, Rust). I think C and Java have the worst ROI when it comes to type systems. In my opinion if you're going to use a type system on a new project today, then use something that provides stronger guarantees like Rust or TypeScript (and lowers the burden by inferring or deducting many types).

Python isn't perfect, but it's still the first tool I reach for anything web, ops or data science related.

This causes issues when working with large data sets or running expensive operations, which is an advantage of modifying a single step independently from the rest.

How do non-engineers update documentation?

Reddit | Senior Rust Engineer | San Francisco, CA | ONSITE, FULL-TIME

We are porting Reddit-flavored Markdown parser from C to Rust and need someone to lead this project. This project will impact millions of users and pages. You should be comfortable in Rust, compilers / programming languages, and be willing to teach Rust to others.

The C version is open sourced here: https://github.com/reddit/snudown

The Rust-specific job is not listed but the closest description is here: https://boards.greenhouse.io/reddit/jobs/655395

Please do not apply through the previous link because we need to route applicants to the specific team. Please email me your resume or any questions: w at reddit.com

10x is a measure of impact relative to others. From that definition, I have no doubt it exists. There's a couple ways to find 10x'ers:

# A person that does things no one else can.

A problem requires calculating taxes for an invoice. Someone who computes this programmatically is better than a person who hand calculates everything.

A problem requires calculating the area under the curve. Someone who uses calculus is better than someone who only knows algebra and geometry.

A problem requires charging a user's credit card once on checkout. Someone who understands idempotent operations is infinitely better. (I was charged 3 times for a single purchase yesterday, and now disputing with the merchant.)

# A person that grows the people around them.

A person growing teammates to 2x or 3x their previously level has a cumulative 10x impact.

This can be teaching how to approach problems, choose the right abstractions, make engineering tradeoffs, manage risk, write robust code that is easily testable, etc.

# A person that makes others more efficient.

If the average dev waits 1 hr for a build, and someone reduces that to 5 minutes then they have saved: x devs * y builds / day * 55 min

This has indirect effects such as maintaining flow state, minimizing context switching, etc.

# A person that brings down the teammates.

A dev that builds fast enough (5x), but grows tech debt such that the rest of the team operates at 0.5x. By definition they are a 10x relative to their teammates. :P

Japan has portable, artificial white noise makers for bathroom privacy. They're called otohime, or "sound princess."

- video: https://www.youtube.com/watch?v=f0eqo6jU9gc

- example gadget: http://www.japantrendshop.com/keitai-otohime-toilet-sound-bl...

- background and wall mounted examples: http://travel.cnn.com/tokyo/shop/sound-princess-loo-001106/

>> he's come upon difficult issues that would be avoided had he had a more comprehensive education.

> he's come upon difficult issues that would be avoided had he had more experience.

I vehemently disagree with this. Education provides the breadth to know where to look for answers. In industry, a developer gains depth as this is mutually beneficial for the employer.

There are fundamental topics that self-taught developers generally don't learn because they're not directly applicable to industry, yet come up in practice all the time:

- compilers / PL theory

- kernel development

- distributed systems

- statistics

- graph theory

The cost of switching jobs to learn aforementioned topics is magnitudes higher than simply taking a course, assuming one can even get hired for a position with no relevant knowledge or experience.

I know a few smart and motivated self-taught developers. They're incredibly productive, but sometimes waste too much time trying to solve known problems in an inefficient manner.

Rust used to have @ and ~ sigils* but they were removed for legibility reasons and difficulty typing on European keyboards.

* For heap and owner pointers respectively.

Kinda late but I want to point out these snippets have different behaviors:

    if A and B:
        ..
    elif B:
        ..

vs

    if A and B:
       ..
    elif A and not B:
       ..

I prefer flattening because enumeration makes it obvious what's different between the branches despite the code duplication.

For example, three boolean conditions has 2^3 = 8 possible combinations. When nested this complexity is hidden but obviously apparent as a code smell when flattened.

It also echoes Python's ethos that flat is better than nested.

Neither are abandoned, I think both projects are in a relatively stable state.

Both projects also have the same basic functionality but different priorities. z aims to be dependency free and simplistic while autojump requires Python 2.6+ but has a bit more features:

- fuzzy matching (corrects for spelling errors)

- sectional path matching helps differentiate between the same directory name in multiple locations:

-- `j var nginx` or `j etc nginx` is enough to differentiate between `/var/log/nginx` and `/etc/nginx`

-- combined with fuzzy matching results in shorthand jumps: `j v ng` or `j e ng`

- `jc` searches only children directories of current path

- opens up a native file browser with `jo <args>` or `jco <args>`

- manual control of path weights: Both z and autojump use frequency and recency to suggest paths, but sometimes I want this newly created nginx path to always win without waiting for the algorithm to learn

- better tab completion

- more shells supported (fish, experimental tcsh and clink support)

Disclaimer: I'm the current maintainer of autojump.

CPython the implementation has a GIL; Python the language does not. Plenty of other implementations (PyPy, Jython, Cython) avoid having a GIL or have options to disable it.

> If you wanted extreme performance Python is a lousy choice in the first place.

Using Python for glue code and C-modules for performance critical work is a popular option.

Here's a listing of Google H1B's base salary: http://h1bdata.info/index.php?em=GOOGLE&job=SOFTWARE+ENGINEE...

Keep in mind that equity makes up a relatively high percentage of a Googlers' compensation. Salary is usually only 40-60% of total comp.

Go is one of the few gc'ed languages that supports static linking[0]. As a result it can solve the same problems as Java / Python / etc but makes distribution significantly easier.

[0] There's a whole bunch (Haskell, OCaml, nim) but none of them have the same popularity and corporate backing that Go has.

You become the goto guy / domain expert over enough things that most of your time is spent being interrupted or in meetings instead of building stuff.

Unfortunately Taylor does something similar with concert photographers (grants Taylor unlimited usage with a large scope, severely restricts photographers' usage):

https://junction10.wordpress.com/2015/06/21/those-in-glass-h...

Similar to Conway's Law:

> Organizations which design systems ... are constrained to produce designs which are copies of the communication structures of these organizations.

— M. Conway

Unused variables have nothing to do with memory safety. At most they'll take up some stack or heap space.

https://en.wikipedia.org/wiki/Memory_safety

Memory safety is enforced in Go via best practices–like C and C++ ecosystems. However because of gc and channels race conditions happen less often in Go but there's no explicitly tooling to prevent them from happening:

http://research.swtch.com/gorace

You're right, I missed this on the first pass:

> There are lots of Wi-Fi hotspots out there but not all of them are high-quality. Project Fi automatically connects you to more than a million free, open Wi-Fi hotspots we've verified as fast and reliable. This technology helps keep your speed high and your data bill low.

For low bandwidth users a ~$25 / mo, intl coverage, no contract plan can be really attractive. I'm not sure how wifi coverage or handoff will perform in real life testing, but it's appealing to have Google pressure US telecom companies the same way they did with Google Fiber.

For family plans T-Mobile's Simple Choice Plan beats Google Fi in most respects:

- No contract

- Unlimited domestic talk, intl talk from US to ~100 countries

- Competitive intl talk

- Unlimited domestic + intl text

- 2.5GB 4G LTE data

- Unlimited domestic + intl 2G data (128Kbps vs Google's 3G 256Kbps)

- Use any GSM phone, not just Nexus 6

- Phones purchased from T-Mobile come with Wi-Fi calling

Most of my family members portion is $30 / mo. Some higher bandwidth users pay $40 / mo for 4.5GB LTE and data rollover. Our family travels a lot in Asia, having unlimited data / text is really useful.

However Google Fi looks like it's really appealing for low usage, single individual plans.