edavis

(Shameless self-plug) https://edavis.github.io/hnrss/ can help you keep a closer eye on /newest via your RSS reader, especially when using searches to limit the posts to topics you're interested in.

You might like https://edavis.github.io/hnrss/

Feel free to open a Github issue with any feature requests.

"RSS feed of replies to a comment" is a particularly good one. I'll definitely look into adding that.

Over the years I've developed two strategies for working with git that have helped me quite a bit:

1) Don't introduce git right away. In the early stages of a project, at least for me, I'm usually making major changes across multiple files. The commits during this time have relatively little value for me. Only once the basic structure has stabilized do I run "git init".

2) The git index is your friend. Always be incrementally updating the index in preparation for a commit. For example, as soon as a new feature has been written or a bug fixed I'll immediately add the changes to the index. Then I'll go back through and look for ways to "clean up" whatever changes I made and then add those changes to the index. Finally, right before committing I'll run "git diff --cached" and ensure each changed line is the smallest possible change necessary to achieve what I was going for.

> Maybe that's a good example of how to get right-wing politicians to agree to some left-wing ideals: prove that it will save money and let them lower taxes.

I think this is a fine approach for the left to take, as long as the moral foundation is never sacrificed.

In other words, it should always be "we should do this because it's the right/moral/dignified thing to do (and if it saves money too, great)" rather than "we should do this because it saves money." Because what if new research comes out saying it _doesn't_ save money?

(See https://www.currentaffairs.org/2017/02/even-when-it-doesnt-s... for a more fleshed out version of this argument.)

Hi all — hnrss.org developer here. Sorry for the downtime. I've spun up some extra resources to better handle the load. Should be back up and working now.

> But why can't the interpreter/compiler implicitly...

"Explicit is better than implicit" -- PEP 20

Python was the first language I ever learned and I just took it for granted that you had to manually specify "self" like that. When I see code with implicit self, it reads strangely to me. Like, "Where does 'this' come from? Oh yeah."

With this workflow, what purpose does requirements.txt serve? Would the file ever be used directly?

Only thing I can think of is you'd track top-level packages in requirements-to-freeze.txt during development, while your deploy would use requirements.txt to get a deterministic environment.

If I wanted to learn more about web development in Java, what's a good starting point? Something that can give me a high-level overview, current best practices, and perhaps a simple "Hello World" example.

I currently work with Django and Wordpress, so I'm not totally new here. But last time I dived into this world, I could not make heads or tails of it.

Java seems like a powerful tool to have in your toolbox, but from what I've found it does not lend itself to be easily picked up.

Or, alternatively, git's building blocks are elegant, powerful, and interesting and writing about them makes for natural blog posts/guides/tutorials.

If you're looking for an alternative, may I suggest giving http://hnrss.org a try?

I built it to scratch an itch, but I love seeing others use it.

Add "?points={10,20,50,100}" to activate the points threshold (e.g., http://hnrss.org/newest?points=50).

Also has feeds for stuff like Ask HN, searches, user comments, etc.

> And yet, I've never succeeded in extracting a straight answer from anyone about why they believe that someone cannot simultaneously have some working knowledge of security and enjoy building PHP applications.

These people are probably thinking: "If you truly knew infosec, you would have moved onto a more advanced language by now."

PHP has a reputation as a "training wheels" language. It's seen as a great starter language to learn the fundamentals of web development, but the expectation is that a "good developer" will eventually migrate to Python/Ruby/Node/whatever once they outgrow PHP.

By staying with PHP, you're signaling that you haven't cleared the bar of being a "good developer" yet.

Is this fair? Hell no. But that's life. My advice? Get familiar with another scripting language. The difference between "I'm a PHP developer" and "I'm a developer that knows Python, PHP, and Javascript" to a lot of people is huge.

I use NNTP to follow a handful of development mailing lists via gmane.org.

I was born in 1989 and my experience is very similar.

As I came of age on the internet in the early 2000s, there were enough vestiges of stuff like Usenet that I was familiar with it but it was clear it was in terminal decline. And I always felt bummed that I missed that era.

Another thing that I really like about this project is how it combines new and old technologies. Like how it's a "standard UNIX computer on the internet" but runs on Amazon's cloud. Collaboration is done via Github. You sign-up via a Google Form. We have these amazing infrastructure tools now which didn't exist 10 years ago. It's really something to see.

I love this. I absolutely love this.

This project hits that sweet spot where "old timers" who remember the lo-fi social web have a place to call their own while also being appealing to the "young guns" who have only ever known the social web in the age of Facebook/Twitter and are looking for an alternative where not everything is easy and beautiful.

What about gmane.org? I don't think it has a download option but that seems like the easiest way to get programmatic access to archives like that.

This past weekend I was looking to add a document database to a side project and I never considered using MongoDB. Maybe it has improved over the past few years, but when I last played with it I found it flaky and unreliable. I eventually found RethinkDB and think I'm going to go with that.

That said, MongoDB is still plenty popular [1]. It's just no longer the "hot new thing" that gets 5–10 posts a day on HN.

[1] http://www.google.com/trends/explore#q=MongoDB

Thanks for the feedback. Really appreciate it.

Your comment hits on a lot of the points that motivated me to create homebrew-emacs in the first place.

For me, Homebrew is a pleasure to use. It's stable, robust, sensible, and has a great community around it.

ELPA, on the other hand, never seemed to have the same polish. Maybe with enough time and energy I could have configured ELPA to my liking. But that prospect never appealed to me when I have a perfectly good package manager I already use for everything else just sitting there.

I wouldn't go so far as to say "no setup."

I just tested it and what if I want to install magit? As it isn't included in the default repo, I'll have to add MELPA. At this point is there much difference between adding MELPA to package-archives and `$ brew tap edavis/emacs`?

And, for me, I already use Homebrew for just about everything else. Using ELPA to manage Emacs and Homebrew to manage everything else is doable — but just not what I'm looking for.

I'd love for one day to be able to run `$ brew upgrade` and have python, redis, org-mode, and magit all upgraded in one shot. The project isn't there yet but I'd love to see it get there.

True, but that isn't a scenario I have to deal with. My development machines are both OSX. If I need an emacs editor on a linux box, I fire up mg. I just haven't needed to provision emacs on a non-OSX machine for years now.

If cross-platform package support is a requirement, then this project is definitely not sufficient.

But as every development tool I use is already managed by Homebrew, this is the more natural extension for me — not ELPA.

Yes. RSS is still primarily how I get my news.

As for how, I built my own reader: https://github.com/edavis/river

It generates a roughly reverse chronological "river of news" (http://rsshub.org/feeds/) via a config file I host on Dropbox (https://dl.dropboxusercontent.com/u/19853263/Feeds/feeds.txt).

If I may brag, I'm pretty damn happy with how it turned out.

I don't think one size fits all here. To me, a good tutorial app is one that effectively showcases the strengths of a framework while being honest about weaknesses.

So for Django/Rails, anything that goes over CRUD operations would be good. For Flask/Sinatra, an API endpoint. For Meteor, a small, realtime chat application. You get the idea.

And keep it simple. Don't try to cram everything into a tutorial — especially if there is a lot of complicated setup required. Just give me the lay of the land and at the end of the tutorial a link to the reference docs so I can keep going if I want.

Been working on this for a few weeks now. Really happy with how it's turned out.

My personal instance is running here: http://rsshub.org/feeds/

Here's the config that runs it: https://dl.dropboxusercontent.com/u/19853263/Feeds/feeds.txt

The YAML config makes this aggregator a tinkerer's dream. By changing the "factor" for a given feed, you can control how fast it drops down the page. The higher the number the slower it drops.

Any feedback is welcome. Thanks!

> I agree they should rename, and after they rename, no one will give a crap about Markdown anymore.

I doubt that. RSS is still widely used even though Atom has the more precise specification.

> Call it Sparkdown or Harkdown or something so the connection is still apparent and move on.

FWIW, Gruber has explicitly endorsed this approach: https://twitter.com/gruber/status/507590561172176897

Because Standard Markdown implies something that MultiMarkdown and Github Flavored Markdown don't: That it is the One True Markdown.

People are acting like Atwood and company are just trying to bring a little sanity to the project when it seems pretty clear (to me anyway) that it's really much closer to usurping the project entirely away from Gruber.

It's amazing how similar this is already to the RSS/Atom format wars:

Widely read blogger independently develops a simple file specification that addresses a real world problem. Simple file format becomes a de facto standard. Developers gripe about ambiguities in the specification. Effort to create a formal, standardized specification is launched. This new effort is publicly denounced by the original specification author.

> There was an obvious, demonstrable need out there for implementation consistency.

I hear this sentiment a lot but I just find it unconvincing.

Over the past decade, Markdown became the lingua franca for transforming plain text to HTML. It did this entirely on the back of Gruber's spec, implementation, and the community that developed around the project. It hasn't had a formal spec this entire time and it's done just fine.

Are there some undefined behaviors in the original spec? Sure. But it was just designed to handle the most common situations, not everything.

A question for the "scripting language" (Python, Ruby, Javascript, etc.) developers who have used Go: How do you like it?

I work primarily in Python but have been wanting to expand my toolkit. I saw a lot of Python programmers get excited about Go so I decided to give it a shot. I spent a few weekends reading through the docs and tutorials and even managed to get some toy programs written.

There's a lot to like about Go: I adore goroutines, "go get" is very slick, and the language as a whole is really well thought out. Really, I do like Go.

That said, it always felt like I was fighting against Go's type system rather than having the type system work to my advantage. It's almost as if going from a dynamically to a statically typed language resulted in a bigger "culture shock" than I anticipated.

I'm curious if other developers coming from dynamically typed languages experienced the same thing. Especially if Go was your first taste of a statically typed language.

I always upvote people who reply to me. Even if they disagree with something I wrote.

For me, the upvote work as "I have read your reply and thanks for taking the time to write it."

Then I'll continue the conversation if there is any more to be said.

"class Position(namedtuple('Position', 'board score wc bc ep kp')):"

Whoa. I've literally never seen this idiom before.

But I immediately like it.

Health insurance. All the terms (co-pay, co-insurance, deductible, premium, etc.) with non-obvious meanings. The delicate dance between me, the insurer, and the health provider when a bill needs to be paid. The whole thing feels scuzzy.

I would probably be more proactive about seeing a dentist or getting a physical if I knew I didn't have the headache of dealing health insurance on the other side of it.

And this is with good (I think) employer-provided health insurance! I can't even imagine the situation on the individual market.