mpolun's comments

It's for proper integration of garbage collected languages -- otherwise you need to embed your GC too, which bloats the wasm. JS host VMs have very good GCs these days, so hooking into them allows for better integration by e.g. go, Java, C#, etc.

Right now wasm is really designed for C/C++/rust

I don't see how it's any different than using any hosting provider. It's probably worth encrypting your databases, but if you don't trust your hosting provider you're hosed -- managed service or not.

If your paranoia is justified (which it may be, depending on your needs), you need to host the machines in your own datacenter

swc (https://github.com/swc-project/swc) is a rust equivalent to babel and has a bundler under development. Not sure how far along it is.

That would be an interesting comparison of performance and features.

Same with postgres. I never use specific lengths for text on postgres.

It's not part of rustup. At least for the VSCode plugin, it'll prompt you to download when it first runs. As long as you've got a working rust installation it'll work pretty seamlessly in my experience.

I don't think this is accurate. Other people may know better, but from my understanding the maintainers of ifconfig realized that to update it to use the new behavior, they would have to end up changing the output. The output of ifconfig is used by a lot of scripts, so changing the output would break a million users, so they decided to write a new tool, rather than add a flag or something to opt into new behavior.

So it's userspace compatibility, not the linux kernel compatibility that lead to a new tool.

(and linux will drop old interfaces if it can be proven that no one uses them, or if they're insecure)

Rust actually has that they just can't be substituted automatically because they're different types:

    fn<T: MyTrait> compile_time(thing: &T) {}
    fn run_time(thing: &dyn MyTrait) {}

The reason that you can't just substitute them is that you can do more with compile-time generics than runtime ones -- runtime generics have unknown size (different concrete types have different size, so what size is the runtime generic version?) so they always have to be used through a pointer (and usually heap allocated). There are a variety of other restrictions on trait objects (runtime generics) for type-system reasons.

It would be possible to find cases where compile time polymorphism is replaced with runtime polymorphism, but I'm not sure it would really gain much given the restrictions.

Now if you start changing the language semantics a lot more becomes possible, but I don't even know what changes you would have to make to the language to let that happen.

There's a permanent mirror of it: https://github.com/mirrors/linux

    > Now time for a concrete example: PaaS – Platform-as-a-
    > Service.  These modern cloud-based technologies enable an
    > extremely lean and agile dynamic response to delivering
    > software for a problem domain.  For a broad class of
    > business applications, this new era of development
    > represents a game changer.  Akin to 4GL for Web 2.0/Rich-
    > Internet-Applications, a team of 1-2 can easily run
    > circles around larger teams using antequated tools like
    > Eclipse or Visual Studio.

What the hell is this guy talking about? PaaS has nothing to do with what IDE you use. Guess what, two well known PaaS systems (Google app engine and Windows Azure) work with the two tools he mentions as "antiquated"!

To the larger point: Great people can do great work with crappy tools, crappy people will never put out great work, even with the best tools in the world.

Well, there's at least one difference: Android is open source, so anyone (even microsoft if they wanted to) could take android and fork it (and make everything but the kernel changes proprietary).

The problem with predatory pricing isn't that they're giving it away, it's that once they've established monopoly, they can change more for it, or restrict access, etc. With android that's just not possible.

Also, technically Android is the property of the Open Handset Alliance, it's just that google does most of the development, especially of big features.

My biggest problem with IDEs is that they often don't like when I want to do something nonstandard. I've had trouble using git with Eclipse (it works, but I spend more time than I want fooling with it), for example. It's usually faster and simpler to add support for a new programming language or environment to a programmable text editor than to an IDE. Currently I'd say that the best environment for working with Go, is to use sublimetext2 and the GoSublime extension.

IDEs are valuable when doing what they were designed for (I use Eclipse when I write Android apps, and I'd probably use Visual Studio if I was going to write something for the MS stack), but I'm rarely doing things that fit nicely into their world, and I end up spending more time fighting with them than they are worth.

That's just for me though.

Also: you can get completion in many text editors if you install the right plugins. See the GoSublime extension that I mentioned for example.

It would be interesting to have a "where are they now?" slide to see how many of those companies are still around and still worth anything. And on a log scale apple, google and microsoft shouldn't blow everyone else too far out of the water.

There may be professions where being accessible at all times is more important than being able to drown out the world and concentrate, but programming is not one of them.

Communication is important too, but when you need to concentrate headphones are invaluable (unless you have a private office)

Is this really a python issue, or a ruby specialty? If you look at programming resources for any language but ruby, I'll bet they're more like the python pages linked there than the ruby ones.

I suspect that ruby just has an especially beauty and design focused culture. Python is a little more old school. This might drive some people away from python, but there are other things that drive them to it.

:= in go means "declare this variable and infer it's type"

You can always use i E = range e or similar, also range is not a function, it's part of go's syntax and always takes one argument. You don't need parens for the unary - operator.

Go does have different syntax from most C derived languages, but the differences are there for a reason. You need to learn any language to understand it.