skysight-inc/HackerNews huggingface dataset:
This is true IME. There are a lot of things you don't need to check for. Some guaranteed by Rust. Others guaranteed by the APIs themselves; Rust gives you a lot of powerful tools for designing APIs with static checks. For example, if you return a Result<T>, you don't need to check if the programmer forgot to handle a failure mode in your tests. The mode will be handled, or there will be an explicit panic.

Rust is harder to get to compile, but a lot of your boilerplate testcases go away. And if you design your API right, even higher-level guarantees can be provided statically.

A lot of times when writing Rust code in Servo I'll just ensure that stuff compiles, and then run the tests once before making a pull request. When contributing to python codebases I generally make smaller, incremental changes and run tests.

Edit: Just to clarify, this doesn't mean you should go all #yolo and abandon testing entirely. But (a) you can do so temporarily without adverse effects, and (b) once you start, you'll find that you only need to focus on the higher level tests.
Why I Couldn't Start with Lisp
Paul Graham convinced me- Lisp was the way to go. That was half the problem- someone was always convincing me that some other language was the way to go. You guys make compelling arguments. But Lisp, man, Lisp _won_ that debate. I wasn’t an expert… but I felt like everyone else was being unreasonable.

It had everything- it was the most powerful coding language, with the most meta features, and someone good with it could tear a project up even without knowing what they were trying to do ahead of time. Count me in!

I spent at least a year on LISP languages- CL, Scheme, Racket. Took the Wizard MIT course, read EOPL, got to Realm of Racket and finally started to feel some of what I felt like programming should be…

At that point I realized that maybe Lisp was a waste of my time right now. I started the iOS apprenticeship at Bloc and I gotta say, it just _works_.

When i hack together an app, it runs. It runs on my phone. It is easy to try out weird algorithms in it and know I'm not screwing up the boilerplate. It's got dead simple and versatile libraries, and I can find online tutorials in everything, and they work or give me errors that are on stackex.

In short, I can use it right away, and tell my friends, and sell it, and Apple will handle the crazy stuff.

I still have high hopes that in five or six years, when I've made tons of apps and know what these libraries are abstracting away for me, i can come back to Lisp and respect its capabilities.

But as a beginner, I found it just too... useless. It didn't make pretty pictures. It wasn't on my iphone, or browser, or anywhere but in its own REPL. As a beginner, I just couldn't get excited about coding without being able to show it off to people (including myself, at the time) who want to _see_ something.

Please excuse my honesty and inexperience. I thought someone might be interested in a just-starting-out standpoint.
Send it an ASCII 7?
I am not a lawyer. But, if a program is not distributed in your part of the world officially, it's not supposed to be illegal to download from different source. After all, the company is not losing any business. So, why not torrent it?
> The very first design decision/belief they made was "no code can perform with garbage collection". Well, garbage collection does cause quite a few performance problems, but that doesn't mean it can't work if you engineer it right.

That's not Rust's philosophy. Garbage collection is great—when it makes sense to use it. Rust is designed to make garbage collection optional, following the way systems software has been designed for decades.

> Mozilla as an organization is not going to be capable of admitting they made a mistake with Servo/Rust and recoding it in Nim.

I've already gone over multiple times why Nim would not be a good fit for Servo (which is not to say that Nim is a bad language, just that it would not be a good fit for Servo).
"Office Code Pro is a customized version of Source Code Pro... The customizations were made specifically for text editors and coding environments, ..."

Interesting, a customized version of a "Source Code" font enhanced for coding and named "Office Code". Am I reading that right?
Google Photos – Can I get out?
Ok thanks. It was not the first decision then, just one of the early main design decisions. I edited the text to reflect that.
Why Mercator for the Web?
Purchase recently expired domains. Spamhaus does it, domain registrars collude with Spamhaus and threatwave/bounce.io.
Because buying a house is very expensive?
Google I/O 2015 – How Google Will Have the Most Profound Tech Impact on Cities
While I agree with some of your arguments, namely that "popularity and merit are not the same thing", I think saying that Mozilla is "trapped in a pseudo-C++ mindset" and that its new browser would ideally be written in Nim is plain wrong.

The fact that using Rust to write a simple website isn't very handy doesn't mean it's a bad language.
Web development simply isn't its primary focus: this is a systems programming language we're talking about. The mere fact that it is being considered for writing web apps is impressive since Rust is supposed to be a better C++, not a better Ruby, Python or Node.js.
Rust mainly emphasizes performance and safety. This means all the 'magic' that happens in a dynamic language is exposed to the programmer, and has a cost: the code is more verbose, and seemingly simple things are more complicated.
I am shocked by the verdict. I just read it. According to CNN, the judge made him responsible for charges that were dropped (paying to have people killed). In theory, he is responsible for everyone harmed by the infrastructure that he created even if he was not directly responsible in the harms.
Great read. I'd recently been discussing with friends the point raised on slide #29 - "Are viruses evolve toward benignity (not eradicate their hosts)?"

General thinking - if a virus was actually beneficial to the host, surely the host would seek it out? I recall reading an article many years ago that mentioned that uncooked red-meat infected most of the population with a virus that subtly slowed reaction times. Flip that around and think about the adoption if there was a virus that improved reaction times.

I'm certainly no expert in the area - just fun to think about if things evolved that way.

This type of thinking can be extended everywhere too. What if the ASK toolbar actually made Chrome faster? Would you install it? ;-)

Enjoyable presentation & certainly made me want to find a book that would educate me on some of the terms used since I'm no expert. Appreciated that some parts where in simple terms.
Finally, an icon dictionary.

It's useful having all these icons on one page with their meanings. Now you can learn Google Icon Language.
Rc and Arc aren't exactly GC types... they are just reference-counted pointers, Rc being akin to C++'s shared_ptr. I get that in a sense, this is garbage collection, but certainly not full-featured like the ones you find in other languages.
Must say that the Lionhead games, while big in what they claim to be doing, fall flat from a gaming perspective compared to the Bullfrog games Molyneux designed (never mind that quite a few big name Bullfrog games didn't have him involved at all).

All in all i find myself thinking that Jobs early on had Woz (hell, in a sense Jobs piggy backed on Woz).

And similarly in the gaming world there was ID software and the combo of Carmack and Romero.

I kinda wonders who it was in the background at Bullfrog that did the grunt work that made Molyneux look good.
Exactly. If Stripe managed to offer SEPA transfers, or integrate with giropay.de or whatever, I would be happy to use that instead. Credit cards are an inferior technology compared to the electronic bank transfers that are common in Europe since the early 80s.
Seems to just be a viral marketing site, but I'm still hoping there's some kind of Alternate Reality Game that we just haven't discovered yet!
The point was probably that coming up with the money for a down payment is significantly more difficult (or less likely) today than it was in the past. Given how many graduates are burdened with loan debt.
Build a Raspberry Pi Webcam Server in Minutes
The figures themselves are a bit boring.

Basic premise of owning vs renting is enough alone really. Unless you plan to move around often it should be blindingly obvious that buying is cheaper. Someone else owns a home and is renting it to you with a profit margin.
This article is idiotic. If I miss out by 65K a year that means prices are advancing insanely. How can that be sustainable? We've seen what happens when banks printing money through land runs ahead of productivity. You get a huge crash and the govt bailout begins.

We badly need a change in the way land wealth is taxed and in the way we issue money. Without this land prices will always rise to soak up all productivity gains.

Today is the anniversary of the peasants' revolt in the UK, by the way.
Hola unblocker discovered to have malware-like behavior
PSA. Every decade or two we get a flood of these so-called "news stories":

- They don't make any more land.

- Real estate only goes up.

- Stop paying the mortgage of your landlord, pay your own!

- Buy now, or be priced out forever!

- (Seattle-only) Californians are moving in and buying up all the real estate.

The real news here is that the stars are aligning to start priming the pump for a new real estate bubble. This time it will be different!
Right. I have several domains, and my email comes in via them. The IMAP server just aggregates them.
Assuming the name was changed because "Source" is the reserved font name in the SIL Open Font License.
You make many assumptions.
Not full-fledged speakers I don't think. But buzzers I assume most have.
Try readelf -d.

$ readelf -d ~/edev/trunk/src/emacs | grep NEEDED
0x0000000000000001 (NEEDED) Shared library: [libpthread.so.0]
0x0000000000000001 (NEEDED) Shared library: [libc.so.6]
0x0000000000000001 (NEEDED) Shared library: [libtiff.so.5]
0x0000000000000001 (NEEDED) Shared library: [libjpeg.so.8]
0x0000000000000001 (NEEDED) Shared library: [libpng12.so.0]
0x0000000000000001 (NEEDED) Shared library: [libgif.so.4]
0x0000000000000001 (NEEDED) Shared library: [libXpm.so.4]
0x0000000000000001 (NEEDED) Shared library: [libgtk-3.so.0]
0x0000000000000001 (NEEDED) Shared library: [libgdk-3.so.0]
0x0000000000000001 (NEEDED) Shared library: [libpango-1.0.so.0]
0x0000000000000001 (NEEDED) Shared library: [libcairo.so.2]
0x0000000000000001 (NEEDED) Shared library: [libgdk_pixbuf-2.0.so.0]
0x0000000000000001 (NEEDED) Shared library: [libgio-2.0.so.0]
0x0000000000000001 (NEEDED) Shared library: [libgobject-2.0.so.0]
0x0000000000000001 (NEEDED) Shared library: [libglib-2.0.so.0]
0x0000000000000001 (NEEDED) Shared library: [libSM.so.6]
0x0000000000000001 (NEEDED) Shared library: [libICE.so.6]
0x0000000000000001 (NEEDED) Shared library: [libX11.so.6]
0x0000000000000001 (NEEDED) Shared library: [libXrender.so.1]
0x0000000000000001 (NEEDED) Shared library: [libXft.so.2]
0x0000000000000001 (NEEDED) Shared library: [libasound.so.2]
0x0000000000000001 (NEEDED) Shared library: [librsvg-2.so.2]
0x0000000000000001 (NEEDED) Shared library: [libm.so.6]
0x0000000000000001 (NEEDED) Shared library: [libacl.so.1]
0x0000000000000001 (NEEDED) Shared library: [librt.so.1]
0x0000000000000001 (NEEDED) Shared library: [libdbus-1.so.3]
0x0000000000000001 (NEEDED) Shared library: [libXfixes.so.3]
0x0000000000000001 (NEEDED) Shared library: [libxml2.so.2]
0x0000000000000001 (NEEDED) Shared library: [libgpm.so.2]
0x0000000000000001 (NEEDED) Shared library: [libtinfo.so.5]
0x0000000000000001 (NEEDED) Shared library: [libgconf-2.so.4]
0x0000000000000001 (NEEDED) Shared library: [libselinux.so.1]
0x0000000000000001 (NEEDED) Shared library: [libfreetype.so.6]
0x0000000000000001 (NEEDED) Shared library: [libfontconfig.so.1]
0x0000000000000001 (NEEDED) Shared library: [libz.so.1]
0x0000000000000001 (NEEDED) Shared library: [libotf.so.0]
0x0000000000000001 (NEEDED) Shared library: [libm17n-core.so.0]
0x0000000000000001 (NEEDED) Shared library: [libm17n-flt.so.0]
0x0000000000000001 (NEEDED) Shared library: [libgnutls-deb0.so.28]
Not all databases have transactions (eg mongo). Not all developers understand when to use them.
While what you said is likely true, the fact remains that if you're not "profiting" from the problem, everyone else is doing so on your behalf.

If everyone else takes a step forward, it's as if you took a step back.
Generally, we just download the pack from git and use the included index.html to browse them:

https://github.com/google/material-design-icons/

They're much easier to browse this way (less spacing / darker color) and you have the assets & resources immediately available.
Sounds a lot like my childhood. I also created my own imaginary world, complete with elaborate drawings and fabricated back history. I was also a voracious reader, remixing those stories into my own variants that fit in with the made up world.

Makes you realize why Minecraft has become so popular among young boys. It's an amazing tool to extend that creativity beyond maps on paper and into something more.
The idea that you can't get something good without a trade-off involving something bad is a false belief, an over-generalization that is very popular among people from all walks of life, including, unfortunately, technologists. Trade-offs do exist, but even a sword in fact has many more than two aspects.
For basic SEPA, You can order the bank to reverse the transaction for up to 8 weeks afterwards. There are different kinds of SEPA transfers though, and I think its different between companies.
NimbleNoggin.io: Using Promises to deal with asynchronous code
The social justice movement demands we be sympathetic to poor people. Using the word 'poorly' might arouse that sympathy before it's established that the subjects of the article are dog-fighting degenerates unworthy of it.
Thanks for this, it seems nice. I've been using SCP for quite a while and this looks like a nice enough improvement to make me switch. I like the inclusion of the Powerline symbols and the tweaks I've noticed to the glyphs and spacing.
Exactly; each of these operations require only 1 query (you don't need to SELECT and then UPDATE), and then a third SELECT query afterwards to ensure the transferrer's balance wasn't reduced to below 0, in which case the save point is rolled back.
Hollywood and the like early on learned to not put real phone numbers into movies etc. Putting in non-functional ip addresses are just as sensible, especially when some teen can point a DDOS at it in a second.
interestingly, when the psuedo 'irc' connection is created, the user's ip address looks to be intended to be the source address..but because someone forgot that there's an akamai proxy in the middle (and didn't adjust for X-Forwarded-For or whatever), the ip you actually get is the akamai ip (its also in the source)

<script>
var USER_IP = '23.62.236.92';

Was curious since the ip appeared real, but wasn't mine.
Most renters pay more than than the owners. A typical breakdown of the rent looks like this:

Rent = Mortgage payment + HOA + Property Tax + Maintenance + Land lord's profit
Auditing your racks periodically is good for many other reasons. RackTables and similar tools are invaluable!
An element that can make bones glow
> is renting it to you with a profit margin.

Not necessarily. Landlords can only charge what the market will bear. If you happen to live in a not in-demand rental market, the landlord will be renting it for whatever they can get.
Refcounting and tracing are two different forms of GC, but you're right in the sense that most people mean tracing.

At the same time, we're putting a lot of thought into how to properly add an optional tracing GC. It's important that it doesn't impact the no-GC case, which is still, of course, primary.
> To compile those numbers, realtor.com compared median home prices and the cost of renting a three-bedroom home in 382 local markets, then factored in estimates for transaction costs, price appreciation, future mortgage rates, and interest earned on any money renters saved when it was cheaper to rent.

But those aren't the only costs. When you rent you are generally shielded from paying for various things, like fixing damage to the apartment or other serious maintenance. Also, renting saves you from the risk of the house losing value because of some local event like a neighborhood becoming less attractive due to a new source of noise or crime. Finally, these estimates assume home prices will rise according to "historical norms", which is a gamble.

Renting also lets you move around to pursue another job in another city, without needing to worry yourself with renting out your current location. The worry might deter you from moving and getting a higher salary, or it might make you spend the time, effort and risk to rent out the place you own, which brings its own costs.

It's hard to quantify those things. Some are unlikely events, some affect the variance instead of the mean, and some depend on the individual (how likely you are to find a job in another city - probably fairly high for people reading HN compared to other industries). But I never see them taken into account in articles like this.
I think Ebay stopped because buyers would get in touch directly with a seller to do re-orders (sometimes at a discount).

Sellers used to be able to Ebay message non-winning bidders and offer them product at whatever they bid at. Sellers would also link buyers to their web-store for that item or related ones. Ebay blocks those kinds of messages. Now sellers do it with a paper pamphlet with your package.

Paypal, on the other hand, wants you to do more transactions, outside of Ebay or not, because they would likely still be the payment processor and get their cut.

It took a while for Ebay to integrate Paypal into the buying process (I'd argue they never really did), so they seemed to always operate semi-independently with non-aligned interests with their parent.
Sorry, not buying that. Just because the sentiments involve extend beyond Northwestern does not mean the Northwestern needs to accept - and indeed, support - an egregiously flawed system for resolving conflicts.

This is a basic sanitation issue. If you run your university that badly, problems like this are a mathematical certainty. The specific set of grievances is immaterial. If it's not one, it will be another.
Well, IMHO, "the right hammer for the right nail".

Rust is a great systems language (besides the lack of bitfields) but I wouldn't use it as a web language. Just as much as I wouldn't use C++ to develop webapps.

Sure you can do it but then again there are far easier ways to achieve your goal.
LOL. I mean... LOL.
No I never said that. My point is that articles like this are written and promoted for ulterior reasons. The right wing believe that the US must maintain an iron grip on the world. Even left wing newspapers like the New York Times have an anti-China bias, because they think that a battle between superpowers is a healthier expression of outgroup-hatred than domestic racism.
Yeah, it's a slightly (but noticeably) tweaked variation of Adobe's Source Code Pro font.
"I see you're running GNOME" snippet:
https://www.youtube.com/watch?v=FQM5fU7V-MM
Dynamic linking is a key innovation that we abandon at our own peril. Only those who are comfortable living in the world dynamic linking creates can agitate for its removal. In a way, advocates of pure static linking are like anti-vaccine advocates.

Here's a killer application of dynamic linking: NSS. It's wonderful to be able to extend applications with new notions of names and addresses.

Remember the bad old days when /etc/passwd parsing was hardcoded and you had a choice of either local users or NIS, and that choice was baked into every application? PAM is another good example.

By the way: there's no such thing as static linking in Windows. All system calls go through ntdll.dll. (In fact, the actual system call numbers are scrambled with every service pack.) This property allows wonderful things, including a pure _userspace_ implementation of 32-bit compatibility for an otherwise pure 64-bit kernel.
I don't consider Java to be statically typed. Sure, there's some compile-time type checking, but OOP is naturally dynamically typed. This is why you end up subverting the type system (I believe it's called "POJO") all over the place when you write Java.

To be pedantic about it, Java has two type systems. It has a bottom-up, mostly static, ALGOL-inspired type system with primitives and arrays (e.g. int, char[], double[][]) and a top-down, semi-dynamic type system for object types.

Maybe, but then the objective isn't so much 'use a static type system' as 'make Haskell palatable to a decent percentage of programmers'. I'm not saying it's impossible to do that, just that it's a different challenge and needs to be understood for what it is.

I agree. What would you suggest?

The issue, I think, that Haskell has is not that the language is hard to use, but that the type signatures can be anywhere from obvious to counterintuitive and, to a beginner, horrifying. The issue is that the "best" (most general, most mathematically accurate) type signature isn't always the one that gels with what we want from it.

An example would be the Lens type signature. It takes some on-paper, figure-it-out work to understand why this is the right type signature. It's this Rank-2 beast:

type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t

When most people would find it more intuitive to have something like this:

type Lensish s t a b = L {get :: s -> a, set :: s -> b -> t}

Sometimes in Haskell we go for full generality and mathematical correctness, which is great, but also makes the language harder to understand.

Then there are the names. Personally, I don't find "monad" or "functor" to be that bad. They're new concepts that must be learned, but they're a lot easier (and more useful!) than OOP's 23 design patterns, most of which are horrible.
Dynamic linking ends up being a wash or a net negative for # of recompiles when you consider that developers of important dynamic libraries break binary compatibility all the time on non-security-related changes.
Reminds me of the pg essay about suits: http://www.paulgraham.com/submarine.html
We have exceptionally low interest rates in USA and EU for 7 years now, but where is the inflation?
You can use full GC in Rust--we use the SpiderMonkey GC to collect Rust DOM objects, for example. It's not the most easy-to-use thing, however.

Most systems software gets by fine with a combination of thread-safe and thread-local RC. Reference counting is a form of garbage collection that works really well when it's used only for the subset of data that needs GC--which is the style that Rust encourages anyhow.
Much better than a different trailer i watched where he basically walked up to a dude in a coffee shop and revealed the dude was running a server containing triple digit terabytes of child porn...
Run a simulated OpenRelay https://github.com/schumann2k/SpamTrap but instead of dropping all mail, redirect it to your target account. Might take a few days to weeks to get started though.
The Web of Things needs your support
Everyone else isn't taking a step forward though, though this article would like to convince us of that. And even if they were, if the step forward means less job and location mobility, then I don't mind a step "back."
You're right, it's easier to learn a third language than it is a second. But Esperanto is super easy to learn in the first place, it gets you to learning your third language that much quicker.
If you're in the Seattle area the gold rush for real estate is definitely back on. The only thing different between now and 2007 is that I don't see as many sign twirlers on corners. Tower cranes and new constructions are everywhere.