jfr

The OpenSSH model implies that you check the fingerprint of the public key before you send encrypted data using that key. That is why SSH shows you the fingerprint of the server key when you first connect, and you have to answer "yes" in order to accept the key and add it to your keyring. You are supposed to have talked to the person managing the system and that person should have given you the fingerprint of the key.

It is virtually impossible for the ISP to intercept and sniff the stream without changing the fingerprint.

The user still has to trust its SSH client.

The problem is not Google, it is DRM and DMCA.

It took years to GCC to arrive where it is because it contained A LOT of legacy code that have been accumulating since its first versions with C++ support. GCC is a compiler that evolved little by little through long years, and many features were added with little design, to fix punctual problems, which made it difficult to converge to a clean implementation.

Clang, on the other hand, had a good deal of proper design to write a clean, robust compiler. The fact that clang reached where it is in such a short time compared with GCC is a good evidence that it is possible to write a good C++ compiler with nice performance and error reporting if you employ good engineering efforts.

Anyways, right at the beginning of the presentation you see the quality of his arguments as he uses a very known problem of a particular compiler (GCC) to bash the language. Sort of a straw man fallacy.

Yes, IOW, it is a compiler problem, not a language problem. Because one particular compiler is horrible on error presentation doesn't mean that the language is bad.

> declared somewhere with static linkage, it can be hard to pin down exactly _when_ that constructor will be called.

The language doesn't define it on purpose. The language leaves it to be defined by the implementation because it goes a little beyond the purpose of the compiler. The compiler transforms C++ source into object code. You can have multiple objects linked together into a single binary, and this linkage is very platform and operating-system dependent. C++ is already horribly difficult to implement correctly; if the language were to define an order for static initialization, it would be stepping on the operating system domain, and make it even more difficult to implement on some systems.

You just jumped to the third phase of the transition plan while the rest of the world is busy doing the first one. That ain't gonna work.

The site will tell if your Internet access will be fine on World IPv6 day. A positive answer means that you either have IPv4 only connection (no broken IPv6 DNS responses or routes), or have a fully operational IPv6 nameserver and route to the Internet. A negative answer means that your computer was tricked into using IPv6 while no actual IPv6 connectivity exists (and thus you are going to have problems on June 8th).

For a more detailed test: http://test-ipv6.com/

From what I remember, the instructions were that ISPs receive no less than /32, which should provide end-users either /48 or /56. End users use the remaining 8-16 bits to partition their networks in /64 subnets. /64 is the minimum routeable prefix, and is the prefix used for automatic configuration.

Linode offering /128 for free and /64 at a cost is ridiculous. Users will have problems to forward since that would require breaking the /64 into smaller networks (to have at least one distinct subnet at each end of the tunnel), which is not possible for radvd.

To be a little pedantic on the subject, such a system (reference counting and immediate freeing) is a form of automatic memory management, but it is not GC in any way. Garbage collection implies that the system leaves garbage around, which needs to be collected in some way or another. The usual approach to refcounting releases resources as soon as they are no longer required (either by free()ing immediately or by sending it to a pool of unused resources), thus doesn't leave garbage around, and doesn't need a collector thread or mechanism to.

There are partial-GC implementations of refcounting, either because items are not free()d when they reach zero references, or to automatically detect reference loops which are not handled directly.

I agree with Torvalds on this matter. GC as it is promoted today is a giant step that gives programmers one benefit, solving one problem, while introducing a immeasurable pile of complexity to the system creating another pile of problems that are still not fixed today. And to fix some of these problems (like speed) you have to introduce more complexity.

This is my problem with GC. I like simplicity. Simplicity tends to perform well, and being simple also means it has little space for problems. Refcounting is simple and elegant, you just have to take care of reference loops, which also has another simple solution, that is weak references. I can teach a class of CS students everything they need to know to design a refcounting resource management system in one lesson.

GC is the opposite: it is big, complex, and a problem that the more you try to fix it, the more complex it becomes. The original idea is simple, but nobody uses the original idea because it performs so badly. To teach the same class how to design a GC system that performs as well as we expect today, an entire semester may not be enough.

http://informationweek.com/news/showArticle.jhtml?articleID=...

    python -m SimpleHTTPServer

    textarea {
       font-family: monaco, courier, monospace;
       width: 500px;
       ...
    }

I'm glad someone said it. This apenwarr seems to have some good karma here on HN, but IMO a lot of what he says is heavily misinformed and biased.

I had the urge to go point-by-point of his post and refute each with proper references and practical examples, but I then I realized that he is just a troll and that would be feeding him.

Some of his points, like about IPv6 addresses being too long and hard to memorize and that NAT is good/enough for users, basically points that he probably doesn't have much experience with network management and how IP works (specially IPv6 networks). This is strange coming from someone who was the original author of wvdial.

I have already argued here on HN why IPv6 addresses are easier to memorize: http://news.ycombinator.com/item?id=1804038

RFC 3986 - Uniform Resource Identifier (URI): Generic Syntax

The problem here is that Microsoft servers respond to /search, /Search and /SeaRCh without distinction. They are all distinct URLs. If it was the intended behavior (stupid, but understandable, coming from Microsoft), then robots.txt should contain all variants in capitalization for each path. A better solution would be to force a 301 redirect to a canonical path, and have this path in robots.txt. Google would work as expected.

The original article is totally bogus. I can't imagine how it has over 90 votes.

Are you talking about the scope identifier or the flow label? The scope identifier is not used by the Network Layer, it is used to disambiguate between addresses in different Data Link Layer outputs by the operating system, but plays no role in routing after the packet leaves the network card. There is no field for it in the IPv6 packet.

The flow label is part of the IPv6 packet, but it is used for routing and quality of service, it is not used for addressing.

So, the IPv6 address is actually just a 128-bit scalar integer, that goes from 0 to 340282366920938463463374607431768211455, with different sub-ranges designated to different purposes.

IP addresses are supposed to be used by machines, not humans (considering network administrators are not humans). Humans should deal with domain names.

They vary in length,

IPv4 addresses also do. strlen("10.1.2.4") == 8; strlen("192.168.123.234") == 15.

The physical addresses don't vary in either case. IPv4 is always 32 bit, IPv6 is always 128 bits.

they're hard to remember,

As an administrator, you can make the particular addresses that you need to remember simple. The last 80 bits of the address are entirely yours, and the first 48 bits are fixed for your entire organisation. With IPv4 you end up having multiple very different /24s dispersed through your organisation, and having to fit your important servers in whatever free address space you can find.

So, for example, you know that 2001:db8:1245::/48 is the prefix for your organisation. It is only one you have to remember. Then you can set your DNS to 2001:db8:1245::1, your web server to 2001:db8:1245::2, etc... Not hard to remember.

they're a little bit harder to parse and print than v4s

This is the sort of problem that you have to solve only once (and it was already solved), then use that function/library wherever you want. See inet_ntop(3) and getnameinfo(3) (as a bonus, these functions work identically to both IPv4 and IPv6, the application becomes agnostic to the address class being used).

Everything fits perfectly. I always wonder if I'm employing my time properly in academia. But they keep me too busy to think about it deeper. Research also keeps anyone tired, too much time dealing with the same problem, lacking some fresh air once in a while to breathe. We are emotionally involved with the work, loyalty and devotion and so on. Intermittent rewards when some of your articles are accepted... And the real awards are distant, the Ph.D. itself.

Think about what happens to "I saw him beating that assassin" if an application decided to cap the string to 26 characters to fit an URL, for example.

Breaking between words reduces the chances of these accidents happening. Sometimes it is not possible (the title is a single big word, or in a language without spaces), in which cases you may want to degrade to the normal slicing.