Announcing TypeScript 2.0 - <AUTHOR> https://blogs.msdn.microsoft.com/typescript/2016/09/22/announcing-typescript-2-0/ <comment><USER2> TL;DR

\- Simplified Declaration File (.d.ts) Acquisition (via npm)

\- Non-nullable Types

\- Control Flow Analyzed Types

\- The readonly Modifier

Finally, I was wating for months :)

<comment><USER3> _Simplified Declaration File (.d.ts) Acquisition (via npm)_

This is huge from a usability perspective.

<comment><USER4> It doesn't seem to be ready. Random thing are broken that weren't in Typings.

<comment><USER3> There's a couple different things we're talking about here. The ability to install typings via npm, which is good because it gets rid of another tool (typings) and everything is in package.json. But the other thing is the ability to consume declaration files in node_module packages themselves, which I consider a bigger win.

<comment><USER4> Why couldn't you do that before? Definition files are just ts files, wouldn't tsc be able to find them in node_modules?

</comment></comment></comment></comment></comment><comment><USER5> I can't wait to use some of the new features in our production apps. Typescript is/was my bridge into javascript development, because IMHO javascript was a broken language for a long time, and I am not sure if I could have ever done as much as I have without its existence.

Non-nullable types, tagged union types, and easy declaration file acquisition are definitely the biggest wins for me with this release.

<comment><USER6> Javascript isn't as broken as you might think.

Non-nullable types, OTOH, might just be the thing that makes me start using TS, despite my love of dynamic typing.

<comment><USER7> Try adding 1.3 + 1.1 and tell me JavaScript isn't broken. Hint: The result is isn't 2.4, it's 2.4000000000000004.

Unfortunately that's something TypeScript doesn't tackle, but you can use external libraries for floats, where you work on floats as... strings.

<comment><USER8> when you work with floats, never expect anything to exactly equal a value, ie, it should be banned to use <float> === <constant> . That is universal across languages, for exact representations often languages provide another type. But floating point is popular because CPUs can natively work with them.

<comment><USER9> For financial work, you want to use a fixed precision or binary coded decimal library, such as java's BigDecimal.

You knew that, but I'm just spelling it out for others.

<comment><USER6> ...Or you could use Scheme, where we have precise numbers (fractions)

</comment></comment></comment></comment></comment></comment><comment><USER10> This isn't really the place for it but I really wish that both Webstorm and Resharper used the actual typescript compiler for its tooling (like vscode) vs handrolling their own. Now I have to wait until Webstorm 2016.3 to see the full benefit of 2.0, rather than getting it for free by just updating typescript. Not to mention the obscene number of typescript edge case inconsistencies in the warnings, errors, and refactorings.

<comment><USER11> You've been able to configure your own tsc for a while, at least in IDEA anyway.

<comment><USER10> I more meant in the form of tooling, not compiling. The intellisense that it provides is often incorrect vs VSCode which asks tsc what the intellisense is, making it always correct.

<comment><USER12> This is possible if you look closely at the settings for TypeScript in IDEA/WebStorm:

> _Select the Use TypeScript Service check box to get native support from the > TypeScript Language Service according to the up-to-date specifications. In > this case syntax and error highlighting is performed based on the > annotations retrieved from the TypeScript Language Service while code > completion lists contain both suggestions from the TypeScript Language > Service and suggestions calculated by IntelliJ IDEA itself._

[https://www.jetbrains.com/help/idea/2016.2/typescript- suppor...](https://www.jetbrains.com/help/idea/2016.2/typescript- support.html#d827982e95)

<comment><USER13> Wow, you're right. This is new by the way, wasn't like this at least in the 1.0 typesript days.

</comment></comment></comment></comment></comment><comment><USER14> Typescript is such a neat project. The js ecosystem is vast and diverse and the typescript team has the unique job of figuring out how to make common dynamic patterns type-safe and convenient. Like... that's so cool. Every little pattern like its own type system puzzle, and there's no _avoiding_ the issue like a ground-up language can do, because their job is literally to type the JavaScript we write today.

Also, how much money is MS pumping into TS? A lot of OSS has one or two super- contributors that carry the project on their backs, but typescript has a small army of smart people with significant contributions.

<comment><USER15> I'm still trying to figure out Microsoft's new end game. Major inroads into OSS, more linux support, VSCode, etc.

<comment><USER16> End game is be relevant to developers. There's an entire org called DevDiv whose primary job is to win developer market share. If developers love your platform and tools, then they won't hesitate to use Azure and the other money making beasts.

</comment></comment></comment><comment><USER17> Control-flow analysis? I think that was Flow's differentiating feature.

Obviously, there are still differentiators between the projects (like TypeScript including a known set of transpilers vs. Flow delegating to Babel), but I'm curious to know if they are converging on their core feature (e.g. how to do type-checking/static analysis).

<comment><USER18> they are. Flow is still quite ahead in term of control flow analysis and "soundness" features, and the type system in general is much richer, but TypeScript is catching up. Flow's tooling is getting better (though it still has ways to go).

It's pretty easy to see where things are going. Advanced type systems (Elm, Scala, ML, Haskell, whatever) have the features we really need, and tooling (IDE support, etc) can use that info to provide crazy good tooling, so any type system developed in 2016 and beyond must have all of these things to be of mass appeal.

<comment><AUTHOR> Hey, I don't see TypeScript as being behind on control flow analysis or anything like that.

If you're referring to differences in the way TypeScript narrow types based on control flow analysis, we don't see one as being "better" than the other, but TypeScript takes a more optimistic approach to avoid putting users in frustrating scenarios where the analysis is too limited. Most users tend to prefer this to the slightly more rigid approach used in Flow, so we felt we made an ideal choice there.

If you have any specific thoughts or ideas, feel free to leave us feedback on our issue tracker.

<comment><USER18> To be fair, it is very, very unlikely that I am better at type systems than someone working on TypeScript, so anything I'd suggest, you probably heard about, and is either already on your roadmap, or was a conscious design decision that we just happen to disagree about :)

I think the javascript type system world is still evolving, and the only "wrong" thing to do is to say "Ok, its a solved problem, let's run away with THIS ONE and kill the others".

As long as we still have at least 2 reasonably well known ones, I'm happy.

</comment></comment></comment></comment><comment><USER12> One of the things I've been really needing is buried in the wiki:

> _Previously flagged as an invalid flag combination, target: es5 and 'module: > es6' is now supported. This should facilitate using ES2015-based tree > shakers like rollup._

So now I can add rollup to my production build pipeline to remove dead code. Nice!

<comment><USER19> Wow TIL, I had no idea this was a thing! It looks amazing!

</comment></comment><comment><USER20> TypeScript is so strange for me. Each time I read something about it, I want to give it another try... then I read some codes and I just can't go further. I like JavaScript as it is, without types on every line of code.

Unlike most people on HN, I like JavaScript. I build web app since 2011. I liked working with jQuery, then Backbone and Grunt, then Angular and Gulp. Now I'm working with React, Webpack and Babel (ES6/ES7) and writing web apps has never been so much pleasure. JavaScript in 2016 is really fine for me. And the common point in my JS experience from 2011 to 2016 is that dynamic typing has never been a problem. I also worked with strongly typed languages for years like Java or C# and I still prefer the flexibility of JavaScript.

So it's strange because I admire TypeScript. The work accomplished by its team is really amazing. And it's so nice to see a single library reconcile developers with JavaScript. But in the other hand, I prefer keeping my JS without types because it just works fine for me and the teams with who I worked.

<comment><USER21> Have you tried starting a fresh project with just TypeScript?

I have no idea how your brain works, but for me working with a non-trivial JavaScript codebase is a nightmare.

TypeScript makes web development fun again.

<comment><USER22> Yeah.

Every making even a small change to a JS codebase you haven't touched in a while that isn't VERY thoroughly tested? (Doesn't even need to be a big code base).

Thinks will break. And you will lose hours of time.

Static typing doesn't eliminate all bugs, of course. But it can catch many common mistakes made in JS.

<comment><USER23> If you don't have tests, why do you think your code works?

<comment><USER22> I never said write no tests.

But static typing catches a lot of things otherwise only caught by tests.

Also, try Haskell. Haskell code that compiles works correctly sursprisingly often. ^^

</comment></comment></comment></comment></comment><comment><USER6> Man, I feel like the only one here who doesn't really like static types. I like dynamic typing just fine (it's crazy, I know: it must be the lisp influence). And if I want static typing, TS feels a bit intrusive. Flow is much better in this respect.

I also don't think JS is the root of all evil, and I use Emacs rather than an IDE (although we do have _really_ good integration with regular JS, in the form of the famous js2-mode, and flycheck's linter integration). I, mean, do you _really_ need your IDE checking your types as you type? It's not _that_ slow, and us Emacs users have M-x compile, so we can run our code, and than jump back to the problematic line when an error occurs, and I know IDEs have similar functionality.

Don't get me wrong: static typing can be good at times, and option static typing and compile-time type analysis are useful tools, and I'm glad TS, Flow, and the like exist. But I always see a flock of comments saying that they couldn't possible live without static types, and thanking TS for taking them out of the hell of dynamism, and wishing there was something similar in Ruby/Python/whatever.

I don't really get that.

<comment><USER24> On the other hand I don't understand how anyone can work with a code base that is dynamically typed. I'm looking at a function parameter in a random file. How do I even begin to work with it?

Unless you wrote the code yourself you pretty much have to run the program first and then REPL to see what the type actually is and the properties it exposes Slow, arduous, unnecessary.

Also especially in the early stages of any development project I am refactoring like crazy as things come together. Static typing enables refactoring operations that are lightning fast with almost zero chance of error. Refactoring in any dynamic language is super error prone and leaves open the possibility for bugs that often show up unexpectedly at runtime.

Do people who prefer dynamic languages actually use the benefits of dynamic typing in the first place? Changing variables from one type to another mid- stream. Dynamically adding properties to objects, using == instead of === etc.. Those things are a recipe for bugs, inconsistency, and unmaintainability right from the get go.

Static typing doesn't feel intrusive, it feels like a flashlight. I don't like coding in the dark, feeling around for what everything is or is not.

<comment><USER25> _Unless you wrote the code yourself you pretty much have to run the program first and then REPL to see what the type actually is and the properties it exposes Slow, arduous, unnecessary._

If the code is well written, then no, to seeing what the type actually is. In a good environment like you have in many Smalltalks, you should be able to compose some implementors searches, then quickly know what you're dealing with. Then you _quickly and easily_ debug the system just to be rigorous. In environments set up by smart people, these actions can be surprisingly quick and easy. (In the same way that git allows for using certain information much more quickly, quantity can become a different quality.)

 _Do people who prefer dynamic languages actually use the benefits of dynamic typing in the first place? Changing variables from one type to another mid- stream. Dynamically adding properties to objects, using == instead of === etc.. Those things are a recipe for bugs, inconsistency, and unmaintainability right from the get go._

None of those things are the benefits of a dynamic language, except maybe as super debugging tricks. No one who really knows how to write in a dynamic language puts stuff like that in typical code! That you say this makes me think you don't know what you're talking about, or your main exposure to dynamic langs has been through the code of yahoos.

<comment><USER3> _If the code is well written_...

 _In a good environment like you have in many Smalltalks_...

 _No one who really knows how to write in a dynamic language puts stuff like that in typical code_

That's the problem. You're talking about some hypothetical, Smalltalk environment, where some expert dynamic language programmers always do "the right thing".

<comment><USER6> Okay then, but if you're not documenting your functions, which is the most important thing, you shouldn't be working on a large project with other people in any case.

<comment><USER26> Documentation will not save you the day you decide to rename a function or change its signature. Static typing will.

<comment><USER6> ...No, it won't. It might make the refactoring a little easier, but with various tools, you can check all the call sites and see if you fixed it. Sure, your compiler won't tell you what's wrong, but your REPL and your tests will.

<comment><USER3> Yes, given enough time for enough manual work, and enough tests, and enough code review....

The whole point is not to have to do this stuff manually, which is very error prone. Ad-hoc REPL work, and tests are very likely to have missed something.

<comment><USER26> Precisely.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER27> I really wish that MS would release typescript as a collection of plugins for babel that would handle only one thing at a time (eg, the type system). Having my production build, es6 transpiler, type system, JSX compiler and so on (including a bunch of features I would rather didn't exist at all) all in one package feels like a failure of separation of concerns.

I understand that people find Babel's plugin ecosystem confusing and intimidating (it is), but I don't think a separate monolithic typescript that reimplements popular babel functionality is the answer.

<comment><USER21> I'm actually glad they release TypeScript as a completely integrated and standalone solution.

<comment><USER27> It definitely has advantages. But I don't think using babel precludes shipping a binary with a standard pre-built config.

</comment></comment></comment><comment><USER28> > _In TypeScript 2.0, null and undefined have their own types which allows > developers to explicitly express when null /undefined values are acceptable. > Now, when something can be either a number or null, you can describe it with > the union type number | null (which reads as "number or null")._

Great news, but I suspect it's going to be pretty difficult to migrate large codebases to account for this properly, even with the help of `--strictNullChecks`. Sounds like days worth of tedious work analyzing every function.

<comment><USER29> Yes, although the same can be said for the "no implicit any" flag when migrating from code bases EcmaScript. They seem to be doing a pretty good job of supporting both legacy and greenfield projects.

<comment><USER2> Yes, I tried "no implicit any" and got nothing working. Problem were mainly 3rd party libs with out-dated, bad or no type definitions.

Is it even possible to use these flags with production code?

<comment><USER30> We've removed nearly all the implicit anys from DefinitelyTyped, so if you're getting definitions from there, you shouldn't see any.

We don't have good data on this but my perception from talking to people on GitHub is that the vast majority of people using TypeScript run with 'no implicit any' on once they get their codebases converted.

(I'm on the TypeScript team)

<comment><USER31> And even if noImplicitAny in 3rd party libraries is not honoured you now have: skipLibCheck which will limit checks to your own code. Details here: [https://www.typescriptlang.org/docs/handbook/compiler- option...](https://www.typescriptlang.org/docs/handbook/compiler-options.html)

I believe it's actually a perf gain to run with this set (but I'm not certain).

</comment></comment></comment></comment></comment><comment><USER32> Highlights:

* npm replaces typings/tsd

* non-nullable types (has to be switched on)

* better control flow analysis (à la Facebook Flow)

* read-only properties

</comment><comment><USER33> Huge TypeScript fan here - been using it since its 0.8x days. And I'm very interested in the new --strictNullChecks compiler flag. But I'm trying to implement that on our current codebase, and I'm coming to the conclusion that it's still a bit premature. There are a lot of very common and harmless JS (and TS) patterns which this breaks, and for which it's been difficult (for me at least) to find a workaround.

Turning on --strictNullChecks flagged about 600+ compiler errors in our 10Kloc codebase. I've addressed about half of those so far, and I can't say that any of them have actually been a real bug that I'm glad got caught. On the contrary, because of the weird hoops it makes you jump through (e.g., encodeAsUriComponent(url || '')), I'd say that our codebase feels even less clean.

<comment><USER34> One counterintuitive observation about introducing stricter type checking into an existing codebase is that it rarely finds bugs. Why? Because the existing codebase typically "already works", in that issues that the type checker might have found were already discovered through automated (or manual!) testing.

The real value of more strict type checking is when writing new code -- you won't need to spend as much time discovering bugs in development or writing tests for issues the compiler is catching.

<comment><USER33> Good point. And I can see that I would have made different (and probably cleaner) design decisions in certain places if strict null checking had been a part of our code from the beginning.

</comment></comment></comment><comment><USER35> Hmm...

        $ npm view typescript 'dist-tags'

        { latest: '2.0.3',
          next: '2.1.0-dev.20160922',
          beta: '2.0.0',
          rc: '2.0.2' }

Yet [https://www.npmjs.com/package/typescript](https://www.npmjs.com/package/typescript) says

>typescript published 5 months ago >1.8.10 is the latest of 447 releases

<comment><USER3> I guess that page just hasn't been updated yet. npm i -g email@example.com will give you 2.0.3

</comment></comment><comment><USER36>
        class Person {
            readonly name: string;

couldn't they have just reused `const`?

<comment><USER30> `const` applies to a binding; `readonly` applies to a property. The difference is important because you can alias a mutable property through a readonly reference (thus observing two different values from the same reference if someone with a mutable handle on the object changes it), whereas a const will _always_ have the same value because it's an immutable reference to a particular value/object.

<comment><USER36> ah i guess immutable aliasing is useful. then it's more powerful than const and can replace it wholesale, bindings included.

</comment></comment></comment><comment><USER37> I've got to find the time to play and get typescript set up figured out. I've had several false starts, always running into duplicate type definition issues and similar problems - looking forward to see if the new @types from npm help things.

</comment><comment><USER9> Does Typescript have a facility to support partial function application?

Say I have a function of arity 4, and want to bind / partially apply (some might say "inject") 2 arguments to it to create a function of arity 2, can TS infer the types of the remaining arguments, or, that the result is a function at all???

I use partial function application MUCH more than classes in the JS code that I write. There just seems to be less to need all that "taxonomy" related refactoring.

"Stop Writing Classes", "Executioner" in "The Kingdom of Nouns" (not!), and all that sort of thing :-)

<comment><USER9> For those of you unfamiliar with partial function application, it's a good way to replace many classes that consist of nothing other than a single "do the work" method and a constructor or setters for the configuration/dependencies with a single function.

You put the configuration / dependency parameter(s) first, and the more "volatile" parameter(s) last. Rather than having a constructor call, you partially apply the things you want pre-bound (config, deps) to create a new shorter function that acts as the "do it!" method.

E.g. - write a function to send emails. Put the "reply to" parameters first. Partially apply that data. Use the resulting function to send emails to specific people. Bind on the distribution list name argument. Use _that_ function to send alerts to those recipients. Bind on the content of an alert. Use _that_ to send an alert when needed, without having to come up with any of the input, just the 0-argument function. Overloading, alternate constructors, subclasses??? Screw that. As long as the parameter order is reasonable (least to most volatile), there is seldom anything to be "refactored"

"Currying" just means that you apply a single argument at a time, until you get down to an "arity 1" function, after which the final argument runs the original function with the last remaining argument, rather than returning an "arity 0" function. Here is an example library that does _A LOT_ of currying: [http://ramdajs.com/docs/](http://ramdajs.com/docs/)

If I apply/bind a function to my higher order function, is that dependency injection, or subclassing? Who cares.

I like arity 0 functions. They make nice event handlers.

I have been gradually converting to Javascript for the last 8 years. My paradigm has definitely shifted. I know how miserable static OOP is, and _won 't_ be going to my grave not knowing :-) (here's the quote: [https://www.facebook.com/groups/nodejsis/permalink/142940052...](https://www.facebook.com/groups/nodejsis/permalink/1429400523804671/))

<comment><USER9> I suppose this is orthogonal to compile time types, but I had to write my own utility to support PFA "decoration" of functions. It of course knows nothing about the number or type of arguments in the original function. (I usually write JSDoc comments about resulting intermediate functions if they leave the nest)

For TS to do this, the compiler would need to supply the "apply"/"bind" feature and track that a function goes in, and the list of argument types, so it can check what is applied and track the types of any remaining arguments. Doable, but if it's not built into the compiler, I have to start running a transpile process that buys very little for much of my code.

</comment></comment></comment><comment><USER38> Awesome release! Yet, I'm still waiting for 2.1 to bring finally async/await generators.

<comment><USER39> Have you tried transpiling to ES6 and then use Babel?

<comment><USER40> It's "yet another 'transpilation(?!)' step". I currently use this combination but I would be way happier with just Typescript as in the current config the lag becomes noticeable.

<comment><USER39> If you use webpack, you could just add ts-loader as a first loader and babel- loader as a second one. Source-map works great too.

<comment><USER31> Yup - though you need to make use of lib if you want to write es2016 TypeScript and have Babel transpile it. Not too hard to get set up though:

[http://blog.johnnyreilly.com/2016/09/typescript-20-es2016-an...](http://blog.johnnyreilly.com/2016/09/typescript-20-es2016-and- babel.html?m=1)

</comment></comment></comment></comment></comment><comment><USER41> Seems the spread operator (a roadblock for a lot of JS interop) will have to wait until 2.1.

<comment><USER42> I'm currently using the spread operator liberally. Why do you think it's unavailable?

<comment><USER43> It's available in JSX but not outside that scope, e.g. const { name, ...rest } = person; won't work

</comment></comment></comment><comment><USER44> Why choose "readonly" as the modifier for immutable properties? A little long, no?

<comment><USER45> Probably consistency with C#.

</comment></comment><comment><USER46> typescript is a nicely conservative set of extensions to javascript, but if you're willing to venture a bit further afield, redhat's ceylon [[https://ceylon-lang.org/](https://ceylon-lang.org/)] is well worth a look. it has an excellent type system, and seems to be under active development, particularly in terms of improving the runtime and code generation.

i played with it for a bit before deciding that for my personal stuff i prefer more strongly ML-based languages, but if i ever have to develop and maintain a large team project i'll definitely give ceylon a very serious look.

</comment><comment><USER42> Still no async/await for ES5 build targets, but other than that a plethora of excellent new features.

<comment><USER47> async-await transpilation for ES5/ES3 target is already available in the nightly drops of TS (`typescript@next`).

</comment></comment><comment><USER48> I gave TypeScript a try but honestly thought it was more trouble than it's worth in most javascript applications/libraries. Maybe that's just the lazy person inside me, or maybe my projects aren't big enough to make use of it's features.

<comment><USER49> I'm curious specifically what friction you ran into.

<comment><USER22> The biggest obstacle for Typescript by far is using libraries which have no or outdated declaration files on DefinitelyTyped.

You can get good at writing the declarations yourself, but it's hugely annoying.

<comment><USER50> Well, you don't have to write any declarations -- everything will just be typed as `any`, which isn't preferable but is exactly what you'd get if you weren't using typescript.

</comment></comment></comment></comment><comment><USER51> Aweyissssss!</comment>


Monitoring Weekly newsletter - <AUTHOR> http://weekly.monitoring.love/ <comment><USER2> > Okay, sign me up!

Uhm... No? I don't know your newsletter's quality. Where's the archive?

<comment><AUTHOR> It's a brand new newsletter from two community menbers who also happen to be authors of two O'Reilly monitoring books, the creator of Monitorama, and a long-time maintainer of the Graphite project. You don't have to believe me but we're going to do our best to release a top-notch collection of monitoring- related stories. We don't have an archive yet but we intend to.</comment></comment>


I published my debut novel to critical acclaim – and then promptly went broke - <AUTHOR> http://www.marieclaire.com/career-advice/features/a22573/merritt-tierce-love-me-back-writing-and-money/ <comment><AUTHOR> Charlie Stross's series on how the publishing industry actually works is also illuminating: [http://www.antipope.org/charlie/blog- static/2010/04/common-m...](http://www.antipope.org/charlie/blog- static/2010/04/common-misconceptions-about-pu-1.html). Most people outside it do not realize how it is structured.</comment>


Ln – NTFS hard/symbolic link command line tool - <AUTHOR> http://schinagl.priv.at/nt/ln/ln.html <comment><USER2> It seems a little unfortunate to have the name clash with the well-known Unix utility (this appears to be intentional? See how the web page is laid out like a traditional Unix manpage, too), but without the same command line arguments as said utility.

If this is important to you (as it is to me), it's worth noting that Cygwin supports creating native NTFS symlinks, and you can use the good old GNU ln (same one you'd use on Linux!) to do so. There are some caveats, but it should at least attempt them. See the documentation: [https://cygwin.com/cygwin-ug- net/using.html#pathnames-symlin...](https://cygwin.com/cygwin-ug- net/using.html#pathnames-symlinks)

<comment><AUTHOR> Like I said in another comment, it's the ACL impedance-mismatch that's the problem with cygwin :(

<comment><USER2> It's a different issue. I sympathize that you can't really back up files with Cygwin and maintain the same file attributes (it's certainly not impossible for them to do it while maintaining a POSIX nature -- FreeBSD and illumos have no issues with NFSv4 ACLs, which are a superset of all the NTFS ones), but as far as making sym- or hard-links to files, Cygwin is perfectly fine.

(And let's not mind that NTFS is complicated enough that almost all native Windows tools won't backup it either. Your best bets are wimlib or dism...)

</comment></comment></comment><comment><USER3> See also the SysInternals junction utility, which has provided NTFS linking funtionality for years:

[https://technet.microsoft.com/en- us/sysinternals/bb896768.as...](https://technet.microsoft.com/en- us/sysinternals/bb896768.aspx)

<comment><USER4> Or mklink, which has been available since Vista.

[https://technet.microsoft.com/en- us/library/cc753194(v=ws.11...](https://technet.microsoft.com/en- us/library/cc753194\(v=ws.11\).aspx)

<comment><USER5> Support for symlinks in Windows 10, at least, just got better (or rather easier) for those of us on the Insider Fast Ring: [https://blogs.windows.com/buildingapps/2016/12/02/symlinks-w...](https://blogs.windows.com/buildingapps/2016/12/02/symlinks- windows-10/#eyD4sr1L28V3K9Kv.97)

<comment><USER5> Replying to self as to not change the actual content of my original post. Since August, I've been using Win10 w/ the Windows Subsystem for Linux almost exclusively for my Linux development instead of ssh'ing into a local VM. I can do 100% of what I need for writing software. I'm primarily a C++/Python developer on linux. My IDE of choice is bash. I use vim as an editor, and gnumake to build, although I use pretty_make.py [1] to format GCC errors a little better and add colorization, etc. I use multiple wide-screen monitors, so screen realestate is not an issue for me (I usually have 2 bash shells split vertically per monitor).

One big downside for me is that I cannot actually run the code I build locally because the codebase I'm working on needs to enumerate & name the network adapters that are present, and WSL doesn't yet (, if ever) support this.

But, for what I'm currently doing, which is code cleanup and goal #1 is just clean compiles w/ no warnings as errors (w/ -Wall -Wextra -pedantic -Wno-zero- as-null-pointer) & links, it's a great productivity saver.

[1] [https://github.com/myint/indent- finder/blob/master/test_file...](https://github.com/myint/indent- finder/blob/master/test_files/tab/pretty-make.py)

<comment><USER6> WSL does support network adapter enumeration as of build 14965.

Take a look at this blog post from November: [https://blogs.msdn.microsoft.com/commandline/2016/11/10/ifco...](https://blogs.msdn.microsoft.com/commandline/2016/11/10/ifconfig- and-network-connection-enumeration-support-in-windows-10-insider-build-14965/)

</comment></comment></comment></comment></comment><comment><AUTHOR> The standout for me is --delorean which is basically rdiff-backup for windows. There's a wrapper script for it here with some extra options: [https://github.com/International-Nepal-Fellowship/Windows- To...](https://github.com/International-Nepal-Fellowship/Windows- Tools/tree/master/ntfs-hardlink-backup)

Also this page badly needs a ToC.

<comment><USER7> rdiff-backup computes reverse diffs between files for multi-generation backup. This looks more like an implementation of rsnapshot, which maintains full copies of old versions of files (rather than reverse diffs). (I run rdiff- backup on Windows and find that it works well.)

<comment><AUTHOR> Ah I'm confusing it with rsnapshot. I'd assumed they were the same. I'm confusing incremental with differential I guess.

Are you running rdiff-backup in cygwin? How do you find it deals with the ntfs ACLs? I'm looking for a way to do incremental full-disk backups that leave the files on disk in a "natural" state, with their original pathnames/ACLs/ADSs and not in some weird archive format. Although I suppose rdiff doesn't count as "weird" being as its open source and well supported.

TBH I'm quite liking the look of the windows built-in backup function, I like the idea of the shadow copy service and storing disk images as VHLs. Booting into the backups in virtualbox sounds cool.

The problem is that the "Previous Versions" get stored on the primary drive, not the backup drive, eating into my free space. Unfortunately one can't set it to use the empty space, it wants to preallocate. You also can't set a time interval, only a percentage of the volume.

As far as I can tell consecutive VHL images don't get stored as diffs or anything, they're separate, meaning I'd really only get one at a time.

Oh, come back Time Machine, all is forgiven.

<comment><USER7> I'm running the 1.3.3 Win32 build ([http://savannah.nongnu.org/download/rdiff- backup/rdiff-backu...](http://savannah.nongnu.org/download/rdiff-backup/rdiff- backup-1.3.3-win32.zip)). It is supposed to handle NTFS ACLs but I haven't looked at it in-depth because my, for my application, I don't need ACLs to be preserved.

I wouldn't think rdiff-backup on Win32 is suitable for an OS backup. I'm backing-up a particular application's directories only, so I can get away with using it.

The built-in Windows Backup's image-based backups are reasonable (at least in Windows 7, 8.1, and Server 2008 R2 and 2012/2012 R2-- I haven't tried it with other Windows versions). You get a VHD file (VHDX in Server 2012) that can be mounted, as you say, in Virtualbox, etc. I suppose it would be bootable, but I'd never thought to try that.

"Previous Versions" is a user friendly interface to Volume Shadow Copy (VSS) that takes periodic snapshots of a volume and presents them in a GUI. Data for "Previous Versions" is stored in the volume that's subject to snapshot.

Windows Backup also uses VSS snapshots to maintain multiple versions of the backup. These snapshots are stored on the backup destination, however. I think you may be conflating the "Previous Versions" feature's use of VSS with Windows Backup's use of VSS.

To access the VSS snapshot versions of the VHD(X) file directly that Windows Backup creates it's necessary to expose the shadow copies (using a variety of different methods-- "diskshadow.exe", or "mklink.exe" being the two most common). You can also use the GUI restore interface to restore files from a previous snapshot of the VHD(X) file.

<comment><AUTHOR> Thanks very much, I spent hours yesterday looking for a specific description of how the VHDs and VSS interacted and couldn't find it. A bit ridiculous really.

</comment></comment></comment></comment></comment><comment><USER8> What's the difference between this and New-HardLink and New-SoftLink, which are part of PSCX? [http://pscx.codeplex.com/](http://pscx.codeplex.com/)

</comment><comment><USER9> Eras, the bane of my existence.

</comment><comment><USER10> *NIX: Hard links since the 70s. Glad Windows is becoming less of a toy.

<comment><USER11> NTFS hard links have been available since NT4, released 31 July 1996.

<comment><USER12> While bsdlove's comment wasn't that great, were not most Windows users not using NT until Win2k, and even then, sym & hard links weren't useful, since you needed (and continue to need¹) administrative privileges to create them?

¹excepting the recent change where a "developer mode" can be activated, but that still doesn't make them useful on an end user's machine, or to an end user.

<comment><USER13> Hard links and directory junctions (the sort of directory symlinks that existed before Vista) never required administrative privileges.

<comment><USER14> Well at least with hard links that's not strictly true. Using official win32 apis you need write permission on the file you're linking to so you can't link to say a system file as a non admin. Try mklink with the /H switch.

Of course that's a bit of a lie, if you use the NtSetInformationFile api you don't need write access :-)</comment></comment></comment></comment></comment>


Ask HN: In an interview, what do you answer when asked "tell us about yourself" - <AUTHOR>

This is by far my weakest point in an interview. I usually do ok when answering concrete questions but when this moment comes, where I have to do some kind of general presentation of myself, I never really know what to say, or what the other side expects to hear.
What do you answer? Do you start from the end or from the beginning? Do you have a speech prepared? How long do you talk, how technical or detailed do you get?
Do you know any example (e.g. video) of what makes a good self presentation?
I feel I really need to prepare this, any pointers or stories appreciated. <comment><USER2> This is my favorite question!

My answer is always something that ties together my entire career. That changes over time (obviously), but my current answer is something like this:

"I like telling stories. I'm an engineer, for sure: my degree is actually in physics, and I worked my way out of that, eventually ending up as the first engineer in a Providence startup. When we were acquired, though, I found that I was really good at explaining not only what we did, but _why_ we did what we did. I moved into sales, closed our first 100 customers, and ended up running the marketing team. When you're small, storytelling is explaining to one person why your product is important. Marketing is just scaling that. No matter what, I want to understand at a technical level what's happening, then help close that gap to make it interesting to people, whether that's in code, sales, or marketing."

It might be apparent that I'm not a straight-up engineer anymore, but I do think it's hugely valuable to point out why you've taken a different path from others, or what drives you. Making it a single truth that guides everything you do (knowing that that's wildly untrue) makes it easy for the interviewer to ask you more in that frame.

</comment><comment><USER3> Reading this thread I actually answer VERY different this question.

I almost never say anything even closely related to the job I apply. I talk about me, what I am as a person, what I like and also what I would like to do in the future. These plans might not even involved the company I'm talking to, I don't really see that as a bad thing.

In the end I'm just being myself, if it does not work I could probably have sneak my way into the job by lying or whatever but in the end, I would have probably ended up miserable so it's a win win.

</comment><comment><USER4> From sitting on both sides of the table, here's the gist of what I'm expecting to hear:

"Most recently I've been working at <company> on <short summary of project>. When I was there, I <two to three things I did which demonstrate that I'm awesome>. In my spare time I've been <something related to programming>."

The point of the question is to get you comfortable with the interview and give you the chance to say a few words on your own terms. The best thing you can do is show me you're someone who can effectively execute on a project, and give me some hooks that we can talk about in more detail.

Don't overthink it. It's an elevator pitch - it shouldn't take more than a minute or two.

</comment><comment><USER5> I think you're struggling because the question is so broad. I'm pretty sure that most interviewers aren't even sure why they are asking the question. Some are probably using it in order to get the conversation going. A much smaller, savvier group might be using it to see how you define yourself. Either way, I tend to ask a clarifying question: "What do you want to know about? My hobbies? Education? Work experience?"

Your answers to pretty much all interview questions should be tailored to the specific job and the story that you want the interviewer to remember about you.

</comment><comment><USER6> It depends on the company you're interviewing with.

If, for example, you founded a tech company, the way you described it would differ whether you were talking to: your parents, a tech journalist, a potential client, a potential cofounder, a potential engineer, a potential product manager, etc.

Each company you talk to will be different and have different needs. No one can tell you what those are—that's your job as the candidate. But to give you an idea, let's say you were interviewing for a 4-person startup. A small startup typically needs generalists who show a lot of passion for the company and their work. Someone who can thrive in scrappy environments without a lot of process and push the company forward in more ways than what you were hired for.

Now your narrative should use any relevant experience, even if it were, for example, working at your parents' pizza shop when you were 15 (in lieu of any actual field experience). "I'm a naturally self-motivated worker who really thrives in smaller, scrappier environments. For instance, my parents' local pizza store was chronically understaffed so I developed a process that could combine X and Y while doing Z so that individual productivity went up 3x. I have a great deal of passion for what I work on and always own the result from start to finish."

</comment><comment><USER7> "I've been playing games since we were old enough to go to the old arcade across the street in Ukraine and then fell in love with Warcraft 2 after we moved to the U.S. and got our own computer. My favorite types of games to play ended up being simulations, so I'm very interested in life simulation in general and have been working on a browser-based snail simulation for several years for fun. My first job in games was in Australia, at a then-AAA company that went down and after that I went on to contract for smaller games companies and businesses doing web development and software QA. Eventually I wanted to move to a country with a better games industry and help to make larger games again, so I arranged a move here while working on my own smaller projects at the same time, which you may have already seen on my website and GitHub [which I would have linked as part of my CV/cover letter]."

Or something along those lines, shortening or going deeper as in-between discussion guides. Mostly I outline my experience with and attitude toward games and making them.

Then again, the last time I interviewed was years ago, so it would no doubt change now to account for later experiences.

</comment><comment><USER8> I give a pretty high level over view of things I would like to highlight. I try to make a point to mention things that will elicit more "concrete" questions. For example, I mention that I just recently moved to Seattle which is usually quickly followed by "Where did you move from?" I tell them I moved form NYC and almost always that is followed by "Oh wow NYC, That's a big change!"

I mainly describe things I want to talk about so that I'm asked questions about those things and I can elaborate on them. The interviewer isn't likely to have an extended dossier on your life (I guess if you were interviewing at the NSA they might) so you get an opportunity here to highlight the things that make you sound best. They can only ask you about what you tell them so tell them some cool things.

</comment><comment><USER9> 1.) Start general ("I'm an x developer with y years experience.) You want to tell them 2-3 selling points ( I have a lot of experience with x, I'm great at y).

2.) Always be closing. Whatever you decide to tell them, put yourself in their shoes and ask "Does this person sound like a great hire?"

3.) Don't be boring. Your 2-3 selling points should prompt them to ask you more about those things. Don't recite your resume.

</comment><comment><USER10> It's not really a question, more of a command, and it's a terrible one at that, simply because it is so vague. I often will just ask the interviewer "what are you most interested in hearing about?" and that generally will lead to a more specific question from them, such as "tell me about your most recent project or job" or "What do you find interesting?" or something to that effect.

I'm a firm believer that an interview is a two-way process, and that if you don't feel a question is a good one, helping the interviewer rephrase/reframe it so you can have a more fruitful conversation.

</comment><comment><USER11> At the tech interview bootcamp [[http://InterviewKickstart.com](http://InterviewKickstart.com)], here is how we think about it:

* The interviewer is looking to break the ice and also get to know what to ask you next.

* For you, it's an elevator pitch, and shouldn't take more than one or two minutes. Too short isn't good either.

* You can give an answer which falls into either of the three categories:

a) An answer that subtly sells yourself. Not blatantly, but subtly

b) An answer that leaves it neutral

c) An answer with which you shoot yourself in the foot

* The key is to prepare beforehand.

If you are __not __prepared, then there are high chances you 'll ramble for a time that's too long or too short, and/or you'll pick words that shoot yourself in the foot. e.g. "... and that project I did, failed. Man, I should have coded faster". Not good.

Or, without preparation, you'll leave it neutral i.e. you'd have wasted the opportunity to impress the interviewer, or lead them into a direction you want them to go into.

You want to target the best outcome (a) above. To do that, best is to prepare with someone (a friend, mentor etc) and choose your words carefully. A good answer to that, has:

1\. Focus: Based on the position you're interviewing for, talk about related work.

2\. A hook or two: A good company you may have worked for, a good OSS project, a good school you went to, any stats on scale you've handled, anything that led to broader recognition etc.

3\. End with what you're looking for

e.g.

1\. "My name is Mia. I am a graduate student at Carnegie Mellon, specializing in Cloud Computing. I previously interned at Google and Microsoft. I'm looking for a fulltime role at a company that interfaces with hardware and software"

2\. "Hi, I'm Praveen. I work as network protocol engineer at Ericsson. I have deep interest in the area and have authored two papers on it. I'm looking to branch out into application level engineering"

3\. "Hi, I'm Mani. I'm a DBA by profession. I held Oracle certifications back in the day. My most recent experience has been with MongoDB in a 24/7 environment with a peak QPS of 25000. I am also very comfortable with managing MySQL and have managed a hybrid environment of 150 instances. I'm looking to go to a place which has a mix of NoSQL and SQL environments"</comment>


Ars Technica Android O Review - <AUTHOR> https://arstechnica.com/gadgets/2017/09/android-8-0-oreo-thoroughly-reviewed/ <comment><AUTHOR> I knew Project Treble was exciting, but this is really interesting:

>Treble promises to change everything. Malchev says that Treble standardizes Android hardware support to such a degree that generic Android builds compiled from AOSP can boot and run on every Treble device. In fact, these "raw AOSP" builds are what will be used for some of the CTS testing Google requires all Android OEMs to pass in order to license the Google apps—it's not just that they _should_ work, they are _required_ to work.

Ron paints a rosy future here:

>Custom ROMs shouldn't need to be painstakingly hand-crafted for individual devices anymore—a single build should be able to cover multiple Treble devices from multiple manufacturers. Imagine the next time a major new version of Android is released—on Day One of the AOSP code drop, a single build (or a small handful of builds) could cover every Treble device with an unlocked bootloader, with a "download Android 9.0 here" link on XDA or some other technical website.

If this comes to fruition, the ROM community is going to go nuts. This is enormously exciting and Oreo will turn out to be a real turning point for Android.

One thing that is interesting though is the implication that Android updates will get more iOS-y in the future. By that I mean certain features will be missing from updated phones because the HAL layer doesn't support it.

<comment><USER2> The implications for the ROM community would be amazing. Reading this, the implication is that the LineageOS project can make _a single build_ that would work on _all_ Android devices that have 1) Treble support and 2) an unlocked bootloader. In the text it is in fact implied that Google themselves make such a 'single' AOSP build/system partition that the device needs to be able to run to pass Google Play certification.

It would no longer mean device specific builds and hoping your device is supported. No longer would it mean that you would have to tactically buy popularish Snapdragon devices to have a chance of some aftermarket support after the vendor inevitably leaves you. You would be able to run Lineage on (Exynos-based) Samsung and Huawei phones, which is either impossible or too much trouble to worth the effort at the moment.

Hell, in theory alternate non Android-based, OSes like PostmarketOS [1] could write their OS to be compatible with the Android HAL and work with that. Stuff like this would have likely made Canonical's life in running Ubuntu on Android devices _much_ easier too.

Vendors could make a system partition with their latest skin version and distribute it to all their devices, instead of only their flagship ones, meaning feature updates can be deployed in a much broader way than is done now. Driver updates will likely still be an issue, but security fixes that pertain to the Android base can still be deployed.

I really, really hope the implications here turn out to be true, and vendors don't find a way to fuck this up.

[1]: [http://postmarketos.org/](http://postmarketos.org/)</comment></comment>


The Delinquent Borrowers Leading a Student Loans Revolt - <AUTHOR> http://www.bloomberg.com/news/articles/2015-10-01/the-delinquent-borrowers-leading-a-student-loans-revolt <comment><USER3> Hey! Glad to see this on HN. I'm a volunteer developer for this group, and we are looking for more hands. If you're interested in helping us out, feel free to reach out to me on GitHub (karissa) or Twitter (captainkmac).

Here's the list of issues (signup/login related) that I'm working on now: [https://github.com/debtcollective/debtcollective- web/issues/...](https://github.com/debtcollective/debtcollective- web/issues/56)

Here's a taste of the future: "Harnessing user data (and combining it with data gathered automatically from creditor websites and public data sets)" \- [https://www.newschallenge.org/challenge/data/entries/debt- co...](https://www.newschallenge.org/challenge/data/entries/debt-collective)

</comment><comment><USER4> Borrowing money is risky, and includes risks beyond a straight up cost/benefit analysis. It also makes the borrow more vulnerable (not just to the lender, but to others as well). It should never be entered into lightly.

I sympathize with these folks who have gotten themselves into this situation, but they did make the choice of their own free will. If they didn't do a proper analysis ahead of time, it doesn't seem fair to shift the cost of their decision onto others who did, or who are responsibly shouldering the burden that they took on.

There is a definite moral hazard in the current system (it encourages indebtedness and inflates the cost of education), but that doesn't make it right to create another moral hazard in trying to correct it.

<comment><USER5> For those trying to escape poverty, disadvantaged teenagers must choose between debt and the permanent surrender of their hopes and dreams. Hardly a situation where the borrower can be expected to make a dispassionate calculation, nor is it a situation where there's a clearly correct course to be found.

<comment><USER6> Education used to be 'free' here in The Netherlands (certain amount of money each month for students). They recently turned this into a full fledged loan. Although the interest is very low it dramatically changes how students approach studies and immediately start to think in terms of ROI ... I fear for the future of Dutch education. I'm glad I just wrapped up my undergrad and am currently borrowing as well for my Master's but thankfully (I'm one of the few) who have 'great' career prospects.

The American system is really really screwed up if you are trying to escape poverty.

<comment><USER7> I think in the USA college is too expensive, but I'm not convinced it should be free. I like the idea of students actually having some skin in the game. Also I don't want tax dollars to pay for someone to study poetry for 4 years for free. You'll get into a situation like Norway, where it takes a master's to get a foot in the door, and no one gets a job until they are 30.

<comment><USER8> Take in mind that music industry could not exist without poetry. A successful song with fine lyrics can have a huge impact in the economy.

<comment><USER9> Imma let you finish, but [http://seatsmart.com/blog/lyric- intelligence/](http://seatsmart.com/blog/lyric-intelligence/)

</comment></comment></comment></comment></comment></comment><comment><USER10> I have to be honest, if some kind of student-loan amnesty ever goes into effect, I'll be a little pissed that I prioritized paying mine off with my earnings for the first half-dozen years out of school. Just imagine what I could have done with those tens of thousands of dollars instead...

</comment><comment><USER11> I like the way that these articles and the comments ignore the elephant in the room: The cost of living while attending college.

Here is a data point for my local State University. I happen to work there, so I can verify that these numbers are pretty much correct. You can pay cheaper rent, but you'll pay back the difference in car mileage and/or roommate drama.

Tuition is (roughly) 40 percent of the cost. What really drives up the student debt is the cost of living. If we really wanted to do something about student loan debt, I think we'd do better to apply the same political pressure to the cost of living as we do to the rate of tuition.

Indiana University [1] Tuition: $10,388 Room and board: $9,794 Books and supplies: $1,230 Transportation: $1,030 Personal Expenses: $2,096

[1] [http://admissions.indiana.edu/cost-financial-aid/tuition- fee...](http://admissions.indiana.edu/cost-financial-aid/tuition-fees.html)

<comment><USER12> The "books and supplies" section would be interesting to break down. How much of it is due to needlessly churning out new editions to cut off the used book market? In the age of the iPad, shouldn't someone be producing first rate, open source textbooks in core subjects?

It's a pittance of the total, but that $1,200 (x4) could still add up to a lot with interest.

<comment><USER11> Let me answer that with a statement and an anecdote.

The statement: The proportion of costs I outlined, from my point of view, have always been true. I finished my first degree in 1997.

The anecdote: All the professors in my computer science program (I'm not going to name-drop, but I had some great teachers that insisted that I learn scheme, then Java, then C, then assembly) either had no required text or gave syllabi that referenced several versions of their listed texts. The context was that we were free to get the best deal possible on the texts.

</comment></comment></comment><comment><USER13> There's two problems when students choose an institution:

1\. Poor and too often manipulated information about a school's job placements.

2\. Students are short sighted about debts and schools don't care because the money is government guaranteed.

Solvable problems! Have an independent party collect and report on job placement. Then tie a school's loan eligibility more closely to the ability of recent graduates to pay.

<comment><USER14> It seems like it would be even better to tie eligibility to the borrower's major. Return on education expenses are more closely related to what you study rather than where you study it: [http://www.economist.com/blogs/graphicdetail/2015/03/daily-c...](http://www.economist.com/blogs/graphicdetail/2015/03/daily- chart-2)

<comment><USER13> If we do both then both the school and student are incentivized! (I was thinking of the for profit schools owned by hedge funds)

</comment></comment></comment><comment><USER15> Those numbers are horrific. My entire UK degree debt will be about $60k at 3% and I won't have to make any repayments until I earn about $30k pa.

For my degree it should be a net profit for me. For less well paid occupations one is insulated against low wages. I am happy that I contribute to the advancements in non vocational learning.

My fellow students and I are said to contribute $40m pa to the local economy which is much needed in this deindustrialised part of the country - <USER2> accommodation is provided by third parties.

But $45k per year is an outrage. It surely can't be based upon the cost of provision.

<comment><USER3> You're right, it isn't. It's largely a for-profit industry, even the 'non profit' colleges. Most teachers, especially adjuncts, make very little in comparison to what the students are paying -- look at NYU, 50k/year per student in a class of 20 where the teacher is paid 5k/class. The math doesn't add up.

<comment><USER16> Would a self organised University be possible in the US system?

A group of teachers using cheap space and online communications to provide lectures/support/assessment with students then taking exams accredited by another institution? Possibly with sponsorship/organisational support from a voluntary sector organisation?

That is basically how most Universities outside Oxford/Cambridge/Edinburgh/Aberdeen started in UK in the Victorian period. The University of London was set up to validate degrees provided by various constituent colleges in the regions. There was a strong non-conformist (Baptist/Methodist) input on the funding and organisational side.

<comment><USER17> Faculty would love to disintermediate the ever growing administration. Accreditation is an issue, and overcoming the importance of brand. Competing with the for profit niche might work though.

</comment></comment></comment></comment><comment><USER18> The absurd student loan system is what fueled tuition inflation in America. It needs to be abolished.

<comment><USER13> Do poor students not get to go to college anymore or do you have another system in mind?

<comment><USER19> Work and save money before you enter a University. If you work and save for 2 years after high school you gain many advantages:

1) You will save some money to pay for school. 2) Because you are a bit older a new world of grants are available to you since you are returning to education. 3) Because your income will probably be fairly low you will qualify for more grants due to this fact. 4) Gives you time to figure out what you want to go to school for and possibly make you take it more seriously when you start.

Another option is to join the military and qualify for a lot of additional grants that way. 4 years of service opens a lot of doors. There are many non- combat roles available.

There are many ways for the poor to advance themselves and not cripple themselves financially for the next 40 years.

<comment><USER13> I like your reasoning, but I worry that the math of minimum wage jobs can't put people through school any more.

</comment></comment></comment></comment><comment><USER20> One way to deal with the student loans crisis is for a nationwide student loan bailout. You don't have to erase the loans, just refinance them at a much lower interest rate. Currently the rate is 7%, which is just insane. For a virtually no-risk loan, which cannot even be discharged in default, that is a terribly high rate.

Refinancing will be a transfer of wealth from the rich to the poor. Good for the economy, shores up consumption, and all that. Has the added side-benefit of freeing indentured slaves.

<comment><USER14> If the current interest rate is high compared to default risk, why hasn't some private company come in to undercut the government and make a killing? I don't think it's because the banks aren't greedy enough. My guess would be that it's because of the extremely high default rate on student loans, and the extremely favorable repayment terms that government loans offer: payments capped at 10% of discretionary income, and forgiveness after 20 years (10 if working in non- profit or government)[1].

[1] [https://studentaid.ed.gov/sa/repay- loans/understand/plans/in...](https://studentaid.ed.gov/sa/repay- loans/understand/plans/income-driven)

<comment><USER20> If that were true, why would private student interest rate be 7% also? It has no such favorable repayment terms.

<comment><USER14> It's my impression that there isn't much private student-loan industry left, having been driven out by federal loans. What's left probably targets a different demographic from the usual one, like borrowers who have already maxed out their federal loans, which might be a riskier group.

</comment></comment></comment></comment><comment><USER21> I think part of "the system" involves learning and lending institutions informally forecasting what the lifetime return on a student's education will be, and then attempting to maximize the return on the student loan(s) as an investment on those future earnings.

The learning and lending institutions clearly fucked up big-time in their forecasting, along with everyone else who was irrationally exuberant in their optimism about the future economy.

Now they are stuck between students on one hand (who have been sold a bill of goods and are seriously pissed about the pittance left over after their loan payments, if they're able to pay back at all), and the investors on the other hand (which includes not only evil bankers' money but also people who have been sacrificing in good faith for decades to contribute to their retirement accounts).

So the stage is set for a nice messy society-destroying generational war that should distract everyone from the forecasting mistakes.

</comment><comment><USER22> Free Education is the primary attribute of a free and cultivated society. If you are living in a primitive country with no free (+higher) education, all available resources should be focused on reaching this goal as the most important evolutionary step.

Many underdeveloped societies and failed states can be identified by looking at the education situation. In the worst cases education is held hostage by a leading group of brutal oligarchs that are raping education into a "business- model" \- these societies will need a lot of help from other nations to overcome the dark neandertaler age they are stuck in and it is important to teach them about the basic abilities of Homo Sapiens Sapiens - solidarity, compassion and love.

Good Luck!

<comment><USER14> Education is never free; it always consumes some resources. The question is who should pay the cost: the student or everyone else?

In cases where basically everyone needs the education to succeed in society and the positive externalities are large (e.g., teaching young children to read), I think that the case for "everyone else" paying is pretty strong. In cases where the education is mostly consumption (i.e., the benefits all go to the student), the case for subsidizing is weak (e.g., a trust-fund kid getting multiple PhDs in impractical fields to have something to do).

So the main issue becomes: where does a Bachelor's degree lie on this spectrum?

1\. Fields of study are very heterogeneous. Some majors have a much larger return on investment than others, so subsidizing all "higher education" equally probably doesn't make sense.

2\. Even in Western Europe, college attendance rates are only around 1/3\. Is it right to have that 1/3 subsidized by the 2/3 who don't go to college, and who on average have lower income?

3\. (More speculative) To some extent, the payoff to a college education is not because of what you learn, but in signaling that you're a smart, conscientious, perseverant person. In that case, a degree becomes less valuable the more people that have them, and the case for subsidizing what has become an arms race becomes a lot weaker.

4\. If we spend a lot of money and effort propping up the current, very expensive, forms of higher education, we might discourage better ways of educating from emerging. One example is something like Coursera, where the marginal cost of adding one more student is basically zero, and everyone can learn from the very best educators in the field. Another would be separate institutions for education and for testing / accreditation. This would help with grade inflation, bring back the focus in the educational institutions to teaching rather than credentialing, and provide more accountability (% of graduates passing a common exam is a lot easier to compare than future income of graduates, and is less confounded by things like socio-economic status of students).

</comment></comment><comment><USER23> Don't pay it and default.

You'll only have to pay the income tax on the defaulted loan.

It's not like you need credit anyways since almost no one in this generation is going to be able to afford a house down payment.

<comment><USER14> If it's a federal loan, the government will garnish your wages [1] and eventually your social security payments [2], and will withold any tax refunds. And since student loans usually can't be discharged in bankruptcy, you'll have bad credit for literally the rest of your life.

Also, you pay income tax on forgiven loans, not defaulted ones.

[1] [https://studentaid.ed.gov/sa/repay- loans/default#consequence...](https://studentaid.ed.gov/sa/repay- loans/default#consequences)

[2] [http://money.cnn.com/2014/08/24/news/economy/social- security...](http://money.cnn.com/2014/08/24/news/economy/social-security- student-debt/)</comment></comment>


Zsh-lovers – tips, tricks and examples for the Z shell - <AUTHOR> http://grml.org/zsh/zsh-lovers.html <comment><USER2> This list is great (and old), but what I would really like is a more concise list of stuff zsh can do that bash can't, and that has been vetted by people who know bash well. (like one thing that comes to mind is recursive globbing with two astersisks, but to be honest I have no clue if maybe bash can do that too by now).

The reason why I want such a list is I usually point people to zsh-lovers list who ask me why I use zsh, but something more to the point would be great, and probably more convincing.

<comment><USER3> > (like one thing that comes to mind is recursive globbing with two > astersisks, but to be honest I have no clue if maybe bash can do that too by > now)

It can, if you set the `globstar` option:

        $ shopt -s globstar
        $ echo **/*.txt
        a/a2/baz.txt a/bar.txt a/foo.txt b/bar.txt b/foo.txt

<comment><AUTHOR> another nice one which i get a lot of use out've.. (again, no idea if bash can do this too)

       $ setopt brace_ccl #put this in your ~/.zshrc

       $ echo {1-3}.pdf {a-d}.pdf
       1.pdf 2.pdf 3.pdf a.pdf b.pdf c.pdf d.pdf

<comment><USER4> Bash can do that easily, the syntax is just a bit different

        $ echo {1..3}.pdf {a..d}.pdf
        1.pdf 2.pdf 3.pdf a.pdf b.pdf c.pdf d.pdf

<comment><USER5> The parent was wrong, and bash can't do the thing he MEANT. The above aren't globs, they just generates strings. None of those files need to exist. In zsh you can use

        <7-10>.txt

to match 7.txt, 8.txt, 9.txt and 10.txt. Zero-padding is loose. 07.txt and 08.txt match also, for instance. The bash {..} syntax just doesn't handle this variable 0-padding case, which is extremely common when looking at a directory full of photos, for instance.

</comment></comment></comment></comment></comment><comment><USER6> I've been using zsh as my primary shell for roughly 5 years. I made an earnest effort in the beginning to read the 400+ page User Guide[1]. Though I learned a lot, it's simply to much information to retain-- especially the things you don't exactly use often. For me, "quick reference" materials like this list have become essential. I've resigned to remembering only the important stuff that I need daily, and for the other things (say, how to write your own completion file for a command that takes a bunch of different types of parameters) I simply remember _where I can look it up_ (the links section of zsh-lovers is probably the most useful simply for this reason). And when I can't do that, #zsh on freenode has been a genuinely helpful community.

1\. <http://zsh.sourceforge.net/Guide/>

</comment><comment><USER7> It's funny to see alias PIPE='|'

That's not much of an alias. Usually I use them to shorten the typing, not make it longer.

Here's my suggestion:

alias "list all files, but don't show much info"= ls

Premature 4/1

<comment><USER8> I could imagine that that is for keyboard layouts where | is prohibitively difficult to type.</comment></comment>


Pixel Art Character Tutorial in Adobe Photoshop - <AUTHOR> https://cool-webs.com/tutorials/photoshop/how-to-draw-pixel-art-character-in-adobe-photoshop/ <comment><AUTHOR> Learning how to draw pixel art in Adobe Photoshop is a fun process as it challenges the artist to focus on a minimalistic way of thinking. It can be quite the process, but the rewards are worth it!

In this tutorial we will be using Adobe Photoshop CS6. There are other programs (paid and free) that have similar options. This tutorial works with many of them. Photoshop has a lot of readily available features for pixel art, and utilizing these features makes the creation process highly suitable for the art process.</comment>


Facebook Appears Set to Debut iPhone Competitor Built on Android on April 4 - <AUTHOR> http://www.macrumors.com/2013/03/28/facebook-appears-set-to-debut-iphone-competitor-built-on-android-on-april-4/

<comment><USER2> In what way would it be an iPhone competitor?</comment>


Should computer programming be a prerequisite for learning statistics? - <AUTHOR> http://andrewgelman.com/2017/05/14/computer-programming-prerequisite-learning-statistics/ <comment><USER2> Learn math, and everything else in life gets easier, including programming. We did a quick proof about similar triangles on the whiteboard this morning and it saved us a bunch of effort. Learn programming, and you can automate some stuff that's too laborious to do by hand. I say, learn math first, then learn programming. Otherwise you're bound to spend your days automating the wrong thing. For programming statistics, I'd spend some time with Tukey's _Exploratory Data Analysis_ before writing any code. It's pretty amazing what you can do with pen and paper.</comment>


Google Mystery Barge A Party Boat, Not A Data Center - <AUTHOR> http://www.datacenterknowledge.com/archives/2013/11/01/report-google-mystery-barge-a-party-boat-not-a-data-center/

<comment><USER2> Not enough power on a boat for powering a data center? Weeeeellll... [http://en.wikipedia.org/wiki/USS_Enterprise_(CVN-65)](http://en.wikipedia.org/wiki/USS_Enterprise_\(CVN-65\)) ;)

(IOW, power is not the primary constraint - I'd be more worried about getting enough _bandwidth_ to/from the ship)</comment>


Cheating in Computer Science - <AUTHOR> http://ubiquity.acm.org/article.cfm?id=1865908 <comment><USER2> Sorry, but this kind of thinking is bullshit. Treating cheating as being efficient and promoting code reuse is just ridiculous.

To actually be a good programmer one should learn how to write code by themselves, and then start thinking about reusing it. If you start with reusing code, you will never be able to code anything new but will always rely on copying other people. You will also always copy other people's mistakes without noticing.

I finished school long time ago and cheating was rampant, and it really pissed me off. All it did was prevent the truly exceptional from standing out from the crowd. Also it gave the faculty a really false sense of their effectiveness as teachers.

<comment><USER3> The point of the article has been missed entirely in this comment.

The author of the orignal article uses the examples of code re-use and efficiency as just that: mere examples of real world considerations that his students should use in class as they would in real life. One lesson has the author providing students with an executable and asking them to reverse- engineer the code: this has nothing to do with re-using code or copying mistakes or cheating. The author creates interesting, useful problems for his students to solve. In this way, the students are self-motivated to learn and grow and problem solve for themselves, rather than simply try to achieve the highest grade by whatever means necessary. The author does not encourage cheating, he encourages engaging students meaningfully.

I, for one, would have loved such a teacher in my CS classes. It might have prevented me from dropping out of the CS program. To add context, I was regularly in the top 5% of my CS classes. I would rush to complete all assignments on my own so that I could spend the rest of my lab time creating my own interesting problems to solve (wherein I would start to truly learn things that would be useful to me even if I was never tested on them directly.) I ended up pursuing (and obtaining) my degree in entrepreneurial management where cheating was also the norm among my classmates, but where I at least felt like I was being taught new things that I would be able to apply in my later life. While cheating was rampant, I never let it piss me off... I simply went on being exceptional and always found myself standing out from the crowd.

<comment><USER4> hristov is _dismissing_ the point of the article rather than missing it.

CS higher education is faced with deep challenges (not least of which is the continuing argument of how much CS should be software-engineering oriented).

Ignoring those challenges entirely though, we should not conflate plagiarism of programs with code re-use. Code re-use is an important part of the "real world." But not in the practice of programming for learning purposes. Exploratory programming and code hacking, as you point out, is a wonderful learning mechanism.

I'm scared when the original article makes statements like "I no longer teach programming by teaching the features of the language and asking the students for original compositions in the language." And you should be too.

I don't worry so much about cheating, but rather more about the end result in the marketplace. Why do organizations shy away from developing their own tools and software internally? High cost with a low likelihood of success? I think that poor software developers negatively influence the _opportunity_ for software development.

There are times when custom software development has significant advantages over the purchase of software solutions. While it is important to actually consider the benefits and costs of custom vs buy, I always feel a little bewildered explaining that we can create and support custom software in-house. I also cringe at in-house software dev shops that primarily are configuration experts and administrators for purchased solutions.

Of course, that same reluctance to do in-house dev is probably a major opportunity for entrepreneurial hackers.

</comment></comment></comment><comment><USER5> Finishing up my undergrad at UIUC. A notable fraction of students in each course do cheat. I see two courses of action: (1) we could take the hard road and seek to catch all dishonest students and punish them or (2) we could make cheating extremely difficult with some simple changes.

I think (2) is the prudent course of action. The majority of cheating that I am aware of is only possible because professors reuse assignments and homework/exam questions from previous years. Solutions are simply passed down each year. One notable exception is in our theory classes, where the faculty make the effort to produce unique homework and exam questions every semester. I believe cheating in the theory classes is far lower as a result and I am extremely thankful that the faculty put forth this effort.

I am cognizant of the work required to generate unique assignments each semester. However, as demonstrated by how departments typically handle quals, it is doable if the workload is distributed. It is my sincere hope that this becomes standard practice. It is the easiest and most fair way to handle the cheating problem. The reason why such a system usually doesn't get implemented in practice is because it requires the entire department to commit to undergraduate education, which is quite difficult to achieve at research universities.^

Some other minor additions to the above system that have a good payoff/cost ratio: (1) static analyzers to detect duplicate code submission and (2) higher weights on exams to punish those who share complete answers on homework assignments.

^Don't take this as a condemnation of undergraduate education in the CS department at UIUC. There are incredible teachers here you'll get an excellent education if you make a little effort to avoid professors whose priorities are elsewhere.

<comment><USER3> The article posits that the question of cheating isn't a matter of catching or punishing the students. It's a matter of creating engaging learning experiences and treating students as the teacher's customers. A student will only get from a class what they want to get out of it; seek a grade at any cost and you'll find a way to earn it, seek to learn at any cost and you'll come away better off (and likely with a good grade to boot.)

So the way I see it, a teacher does have two options: (1) try to force students to learn by trying to make "learning" the only way to earn a better grade, or (2) try to encourage students to learn by trying to make "learning" feel like the rewarding experience it should be. Note that neither of these approaches involves catching or punishing students, nor does it involve forcing students to learn in order to achieve a better grade. If in the end you're a student who finds yourself with the same grade as someone who cheated their way through the class, so long as you got what you paid for (an education), why should you care?

<comment><USER5> Whoops, I meant to mention that. Creating an engaging learning experience is the most difficult option of all. It needs to be done, but there are steps that should be taken in the mean time in order to a more fair (but admittedly suboptimal) environment for students.

A couple of things unacknowledged in your argument. First, there's the practical implications of cheaters on GPA. Cheaters get higher grades than what is possible without cheating, making the curve in a class lower than what it would be in a completely honest classroom. I'll be the first to champion someone who doesn't care about GPA, but there are concrete affects that a lower GPA has on students. Even though you got a good education, it's still something to think about. Second, there's the fact that the solution you propose is not possible in the current system. The incentive structure is all wrong (read: nonexistent) for undergraduate teaching in universities. Further, the majority of professors don't even have the requisite skills to be good teachers. Even if we did get the incentives right, the talent simply isn't there. To be honest I doubt there are enough people on board with improving undergraduate education to get it done.

</comment></comment></comment><comment><USER6> Great attitude. 'I tend to see "cheating" as a symptom that something is wrong in the system, in pedagogy.... As a teacher, my job is to help students learn, not create artificial barriers to learning in the name of equitable grading. Grading should be a strategy for making learning more satisfying by demonstrating accomplishment....

It is my job to satisfy the student, the paying customer, not the other way around. Perhaps cheating is a strategy that students bring to an artificial problem that I have created. Perhaps it is a symptom of my failure to teach.'

<comment><USER7> After four years of being a student at a major state university, I can sadly say that I have never had a teacher with that attitude.

<comment><USER3> I guess I'm extremely fortunate; I had two: one in economics and one in accounting. I very nearly switched my major to economics or accounting because of them. I ended up with different teachers for next-level courses and realized it was the teachers and not the discipline that I found appealing.

</comment></comment></comment><comment><USER8> This gem pretty much sums up the current state of the entire academic world, or at least all of it that I have been exposed to (4th year engineering student at University of Illinois Urbana-Champaign).

"I suggest that we have gotten the cart before the horse. We are less concerned with whether students learn the right thing than whether they learn in the way that we rely upon to measure how well they learn when compared to their peers. We do this without even having considered whether the measurement is even useful, much less necessary or even counter-productive. We do it without considering whether encouraging sin is a good way to teach morals. We do it for no better reason than tradition, habit, and inertia."

</comment><comment><USER9> The other way to handle this is using automated systems to weed out cheaters early in the degree program.

Christian Queinnec set up what is probably the world's coolest interactive tutoring/assignment/testing environment for the introductory programming courses at Université Pierre et Marie Curie that has tools to detect cheating. He gave a very interesting talk about it at ILC 2007:

[http://www.international-lisp- conference.org/2007/speakers#q...](http://www.international-lisp- conference.org/2007/speakers#queinnec_christian)

</comment><comment><USER10> I'm appalled that the author puts most of the blame on the faculty. I would hope that CS students had some personal integrity.

Dartmouth College addressed this in a number of ways:

1\. Collaboration was routinely encouraged, so long as all work was properly credited. You weren't expected to be able to ace some of the theory classes by yourself, for example.

2\. Many courses included large team projects.

3\. Each course began with a clear, unambiguous description of what behavior constituted cheating, and which types of collaboration were allowed.

4\. When caught, cheating was treated as a major offense: a 9-month suspension and a permanent annotation on your transcript for a first offense, and an irrevocable expulsion for a second offense. I was friends with a CS TA who _always_ took the time to ram through these penalties.

Even with those precautions, we had a cheating scandal in a non-major course. Unfortunately, it was hard to identify the cheaters, and the usual penalties couldn't be enforced.

Still, I do admire Dartmouth both for encouraging collaboration and for ruthlessly ending the academic careers of students who lacked personal integrity.

<comment><USER11> The reason these articles focus on the faculty is because students will only be in a particular class once in their whole lives (everything going according to plan), whereas the professor teaching that class will do so many times. This is why articles like this put the blame on the faculty: it's pointless trying to reform student behaviour because the next batch of students in 6 months' time won't have learnt anything at all from any punishments you dished out to the last group.

> it was hard to identify the cheaters, and the usual penalties couldn't be > enforced.

This might be a common problem. My university had similar draconian penalties for cheating, but the seriousness of the penalty requires an appropriately- serious proof of culpability, and it's surprisingly hard to get one.

</comment></comment><comment><USER12> Writing code is also very important and should be taught in CS school. As stupid as it sounds, but the best way might be in the middle. Giving tasks to create code and also giving task to reuse and change code. That is how our teachers try to teach us and I feel acceptably comfortable in both situations, writing a new program as well as moving around in other peoples code.

One thing I want to add: The really bad thing about these "reusing" students is, that they have no skill to see which code to reuse. Most code you find with google is just duct taped itself. And trying to solve any problem with ducttaping an already ducttaped monster is ridiculous. What I saw in my undergrad classes from my classmates was so bad to read and use, that I decided for myself to write a lot by myself and don't rely on others. That got so far, that in one project I wrote my own linked list instead of using the Java's basic one. Of course that is a little too far, but makes for a small, funny story. I'm still not a really big fan of reusage, because design and engineering is something that is treated to lighthearted by many many coders out there. Until you are finished analysing all the options, you often have constructed your own solution and learned more about the innards on the way.

</comment><comment><USER13> After college, I have taken many classes and taught many classes. All of them involve the student paying the instructor to teach them something. If the student does not want to learn, he will not show up, let alone pay his own money to the teacher. If the teacher doesn't teach well, he won't get any paying students.

There are no exams, and there is no cheating, because there is simply no point to either. Though there is homework.

</comment><comment><USER14> When I was doing my CS Degree The university's policy for cheating was Zero Tolerance, it was generally a zero in the particular assignment, failing grade in the course, or expulsion, depending on how grievous the offence.

The CS department did it a little differently. It is fairly easy to tell if you copy a programming assignment(loop structure is identical, code is identical, variable names, etc.), so what they would do is divide the total grade of the assignment and split it between all the people who copied, so if 4 people copied, there was no way to determine who copied who, so the maximum mark you could get was 25%. This happens once and no one wants to cheat simply because by letting someone else copy of you, you are taking a chance at screwing yourself.

Collaboration was still encouraged, but wholesale copying obviously punished.

<comment><USER15> This is a terrible policy which rather encourages cheating.

Let's say that two students need help from one another on parts of an assignment. If they cheat their chance of getting caught is 50%. If they don't get caught their grade is (it doesn't matter for purposes of discussion) a 100 each. If they don't cheat they get a 0 each because they just can't complete the assignment.

So the expected payoff from NOT cheating is 0.

And the expected payoff from cheating is 0.5 * 100 + 0.5 * (100 / 2) = 75.

Who wouldn't cheat? Even if the probability of getting caught was _100%_ , you'd expect to get a 50. Holy cow! What university IS THIS?

The only way to discourage cheating is to make the net utility of cheating negative, and so negative that every student realizes it.

<comment><USER14> Besides the fact that the expected value for not completing the assignment isn't 0. You would get partial marks for completing what you could,assuming what you complete is correct, the outcome isn't binary.

If you would get partial marks for completing what you can, where is the upside in cheating in this scenario where the maximum you get is 50%, which you may get from your partially completed assignment.

Cheating is always taken on a case by case basis. There is always a chance that if you get caught doing this(or doing this more then once), you could easily get a zero in the course, expelled or one of the other university's regulations.

I think the entire point for this initial leniency I think is that on an assignment where you are encouraged to collaborate, some students can cross the line from collaboration to copying.

<comment><USER15> > If you would get partial marks for completing what you can, where is the > upside in cheating in this scenario where the maximum you get is 50%, which > you may get from your partially completed assignment.

There are two factors to utility: probability of getting caught, and the outcome of getting caught.

The problem is that the probability of getting caught, while substantial, is actually much lower than 50% in my experience. As a result the payoff differential has to be that much worse.

Let's revisit my example. In order for cheating not to be the _smart_ thing to do, the expected grade for not cheating would have to be over 75!

And that's with a ridiculous 50% chance of being caught. Now if we lowered the probability of being caught to, say, 25%, the expected grade for not cheating would have to exceed 0.75 * 100 + 0.25 * (100/2) = 87.5.

It's a terrible, terrible policy.

</comment></comment></comment></comment><comment><USER16> The problem is that the incentives are screwed up - most students don't care about learning the courses, but they simply needs to pass them and so do the minimum necessary to get by.

What we need to do is to remove grades as something which you can use to validate yourself to others, and use it strictly as an internal measure of how well you understand the material and what you need to focus on.

</comment><comment><USER17> Writing these kinds of assignments is hard, however. I find it difficult to come up with something that is both wrong enough to be instructive and non- obvious, as well as reasonable enough that someone might have written the code in the first place.

More power to the OP if he's able to write entire, semester-long curricula based on these sorts of assignments.

</comment><comment><USER18> Do employers actually care about a degree in CS anymore? It seems that evaluating skill (which you can learn in school or out) is way more important than a piece of paper. Deciding to pay for said piece of paper, but not learning anything is cheating yourself.

</comment><comment><USER19> _In any case, we can divide pedagogy from credential granting. The British have done it with positive results._

Really? That's news to me, and I'm in the late stages of getting some credentials granted by a British University.</comment>


Brebis 0.9, the fully automated backup checker, released - <AUTHOR> http://carlchenet.com/2013/12/26/x-mas-present-brebis-0-9-the-fully-automated-backup-checker-released/

<comment><USER2> What a good news ! Automated backup check made simple. The Python code is clean and fully tested, good job dude !

<comment><AUTHOR> Thanks, we are really careful about developing a strong code with a good cover. We use coverage, a really nice tool. And our stack includes buildbot and pylint too.</comment></comment>


Universities – Where Does the Money Go? - <AUTHOR> http://devnambi.com/2015/uc-analysis/

<comment><USER2> An OK analysis, but it should be titled, "University of California -- Where Does the Money Go?" There is no reason to believe these numbers are representative of universities as a whole.</comment>


Live: Guido van Rossum talks about Tulip (asynchronous I/O for Python 3) - <AUTHOR> http://nicholsonjf.com/blog/guido-on-tulip In five minutes, the creator and BDFL of Python Guido van Rossum will give a talk at LinkedIn, Mountain View about Tulip (asynchronous I/O for Python 3). <comment><USER2> Man, is twisted cursed or what? By that I mean it provides a great framework for asynchronous things and does it in the what you might call the node.js style with callbacks except it has great engineering, and yet no one seems to know about it or care very much.

<comment><USER3> > no one seems to know about it or care very much

This is why.

Twisted: [http://twistedmatrix.com/documents/current/api/moduleIndex.h...](http://twistedmatrix.com/documents/current/api/moduleIndex.html)

Gevent [http://gevent.org/contents.html](http://gevent.org/contents.html)

<comment><USER4> From the Twisted link: "twisted.manhole", is that an underground punk band from the 80's?

<comment><USER5> manhole lets you attach to a running process and muck around. It's a pretty neat feature.

</comment></comment></comment></comment><comment><USER6> The hangout recording is there now but the actual talk starts at around the 44:30 mark

</comment><comment><USER7> The sound is horrible in this video, here's a better one.

[http://www.youtube.com/watch?v=1coLC- MUCJc](http://www.youtube.com/watch?v=1coLC-MUCJc)

<comment><USER8> That video is from October, is it the same speech?</comment></comment>


Improving DataView performance in V8 - <AUTHOR> https://v8project.blogspot.com/2018/09/dataview.html <comment><AUTHOR> > We found that our new DataView implementation provides almost the same > performance as TypedArrays when accessing data aligned in the native > endianness (little-endian on Intel processors), bridging much of the > performance gap and making DataViews a practical choice in V8.

thread on twitter: [https://twitter.com/v8js/status/1041981091727466496](https://twitter.com/v8js/status/1041981091727466496)</comment>


Our New Pricing and the Evolution of Bitcasa - <AUTHOR> http://blog.bitcasa.com/2013/11/19/our-new-pricing-and-the-evolution-of-bitcasa/ <comment><AUTHOR> From day one Bitcasa has emphasized unlimited storage for all users. Looks like they couldn't pull it off despite all their boasting and promises. Either that or this is a money grab.

</comment><comment><USER2> Apparently they just secured an $11m round of funding, but the investors might as well have burned their money. Their sole differentiator was the promise they couldn't keep: infinite storage. Now they have introduced "new and exciting" features (like a 10x price hike) all that is left is alpha-quality software that leaves you unsure if your back-ups are actually backed-up, rather than corrupted. Bitcasa is on Death Watch. They are a joke.</comment>