Slashdot Mirror

Honest question. I want to know.

Because I run Linux on VMs when I'm trying to do platform-specific work (and, as a core developer for a library with rather a lot of platform-dependent - and platform-OS-version-dependent - code implementing those attempting-to-be-mostly-platform-independent APIs, there's a fair bit of that involved).

As a result, I want to spend as little time as possible dicking with the OS, leaving as much time as possible to actually adding new capabilities and fixing bugs. Ubuntu seems to do a good job of that; if you have another distribution to recommend for this, please do. Note that, whilst I haven't yet had to do any kernel work (other people fixed the kernel issues before I got around to building a kernel with my changes), I'd like a distribution where the process of building and installing a new kernel is as simple a process as possible. Fedora fails here. (In the OS on which I last did kernel work, it's pretty much

make; mv /mach_kernel /mach_kernel.save; cp mach_kernel /; reboot

and it was, as I remember, similarly simple in the previous UN*X on which I did kernel work.)

Honest question. I want to know.

Because I run Linux on VMs when I'm trying to do platform-specific work (and, as a core developer for a library with rather a lot of platform-dependent - and platform-OS-version-dependent - code implementing those attempting-to-be-mostly-platform-independent APIs, there's a fair bit of that involved).

As a result, I want to spend as little time as possible dicking with the OS, leaving as much time as possible to actually adding new capabilities and fixing bugs. Ubuntu seems to do a good job of that; if you have another distribution to recommend for this, please do. Note that, whilst I haven't yet had to do any kernel work (other people fixed the kernel issues before I got around to building a kernel with my changes), I'd like a distribution where the process of building and installing a new kernel is as simple a process as possible. Fedora fails here. (In the OS on which I last did kernel work, it's pretty much

make; mv /mach_kernel /mach_kernel.save; cp mach_kernel /; reboot

and it was, as I remember, similarly simple in the previous UN*X on which I did kernel work.)

> Tony? Who the fuck is Tony?

I feel the need to introduce myself. I am Tony Mobily. I started Free Software Magazine back in 2004 (!). I wrote about 200 articles on FSM (and many others for Linux Journal and other magazines); some of my articles were published here on Slashdot a few years back

  I am also a very active free software coder. Amongst my repos, the most exiting one is Hotplate. I am in the process of documenting Hotplate as we speak. However, I am especially proud of JsonRestStores.

I have been promoting free software since 1994, and have installed Ubuntu _countless_ times for friends, relatives, and for people I didn't even know.

The overlay ad was there because I am rebooting Free Software Magazine, and I am considering _all_ venues in terms of financing articles -- articles which are then released under a free license. However, since I am not here for the quick buck and I anticipate a lot of hits from Slashdot, I turned the ad off.

I love Ubuntu as a distribution and I think Canonical is doing a lot of things right. However, I feel very uncomfortable with app stores confusing free, zero cost, in app purchases, etc. Seeing such a confusion un _Ubuntu_ itself is particularly painful to me.

I hope that answers the question. I happen to be travelling right now, and comments will come during my night time.

> Tony? Who the fuck is Tony?

I feel the need to introduce myself. I am Tony Mobily. I started Free Software Magazine back in 2004 (!). I wrote about 200 articles on FSM (and many others for Linux Journal and other magazines); some of my articles were published here on Slashdot a few years back

  I am also a very active free software coder. Amongst my repos, the most exiting one is Hotplate. I am in the process of documenting Hotplate as we speak. However, I am especially proud of JsonRestStores.

I have been promoting free software since 1994, and have installed Ubuntu _countless_ times for friends, relatives, and for people I didn't even know.

The overlay ad was there because I am rebooting Free Software Magazine, and I am considering _all_ venues in terms of financing articles -- articles which are then released under a free license. However, since I am not here for the quick buck and I anticipate a lot of hits from Slashdot, I turned the ad off.

I love Ubuntu as a distribution and I think Canonical is doing a lot of things right. However, I feel very uncomfortable with app stores confusing free, zero cost, in app purchases, etc. Seeing such a confusion un _Ubuntu_ itself is particularly painful to me.

I hope that answers the question. I happen to be travelling right now, and comments will come during my night time.

If invoking an API is a derivative work of the API, then the Linux kernel is actually as infectious as the Affero GPL, and so are network APIs.

The Linux kernel clearly defines userland software as not being derivative. You can see it here. Networking APIs are part of the POSIX standard so that's not a problem, and network protocols can be copied under fair use for interoperability purposes.

Note that "calling an API" is not the question before the court. The question is whether you can copy the collection of APIs as a system for other people to call. No matter how this ruling goes, you will still be able to call an API as before.

They started to cripple the Linux client as well; since last year it ONLY supports PulseAudio. And it natively supported pure ALSA before that, so it is a feature being removed and replaced with an inferior solution.

Luckily someone created apulse, an emulation layer that allows you to run Skype without the hentai-tentacle-monster known as PulseAudio:
https://github.com/i-rinat/apu...

The best part is how they tout the fact that "Hi there, Skype works without Pulse Audio for features like chat as well as sharing files and photos." on their blog, like anyone would use Skype for the text chat features, and that it would somehow make up for the lost functionality: http://blogs.skype.com/2014/06...

Like many other technology companies, Khan Academy applies for patents in the normal course of business to protect ourselves and our learners from litigation. We do not profit from our patents nor use them to stifle innovation.

As a not-for-profit organization, and to meet our commitment to using patents for good, we have adopted the Innovator’s Patent Agreement and made it an integral part of our company culture. By signing IPAs with our employees, we safeguard innovation and pledge not to use their patents in offensive litigation without their permission, while retaining the ability to protect ourselves against any company that initiates a lawsuit against us.

Since you asked, here are some mods/modpacks for you to try out:

More Blocks
Homedecor
Pipeworks
Gloopblocks
Streets
Infrastructure (cheapie's version)
Carbone MOBs (separated out from the Carbone subgame)

A few that do change the gameplay somewhat radically:

Plantlife modpack
More Trees
Technic modpack

There are a ton more on the forums. All of the above can be used together (as is usually the case with this engine).

Disclaimer: I maintain and or contribute to several of these.

Pretty happy with minetest, a FOSS minecraft clone. Its default setup perhaps has less features than minecraft, but it can be modded much better than minecraft.

Here's the link to the repository

Since you're already using GitHub..

Note what they mention at the end:

You can also attach binary assets (such as compiled executables, minified scripts, documentation) to a release.

As someone who actually uses SourceForge in the way it was originally intended, i.e. a place to host one of my software projects, this is certainly something I would not want to happen. What is a good alternative? Right now I mostly put release tarballs on SourceForge, the git repository and wiki pages have already moved to GitHub.

You can use this wrapper to use the chrome flash plugin with Firefox. It will not speed up flash, though.

A Raspberry Pi powered, sound-sensitive disco suit: https://www.dropbox.com/sc/yd1... Code: https://github.com/chrisgagne/...

I'm in the UK too, and as much as this ever steepening slippery slope has accelerated - i've passed through the phase of caring what ill conceived ideas politicians attempt to subject their corner of the internet to.

Instead i think we need to thank them in the same way that we thank malicious users for highlighting a poor design, the internet needs to be more decentralised (yes i know darknet etc, but it needs to be decentralised and un-cencorable for everyone, not just some obscure part of the web). Well established and stagnant technology tends to evolve when it needs to, and now it needs to - so here's me saying thanks Cameron... thanks for being a massive fucking dickhead, because sometimes the world needs dickheads like you to evolve.

On a more pragmatic note: route your internet somewhere else, buying a cheap chunk of cloud is just too easy these days, as for choices of technically how to route... you could either use the horrible TCP over TCP type old style VPN tech, or you could go spartan and ssh proxy individual ports (but it's a pain), or (i recommend) you use sshuttle which is as Spartan but more VPN-like without the TCP-over-TCP nastyness ++ for zero config on the server side too https://github.com/apenwarr/ss...

You'll get a lot of insights on C++ after doing do.

- http://yosefk.com/c++fqa/

- http://stackoverflow.com/quest...

- https://gist.github.com/klmr/5...

- http://c2.com/cgi/wiki?CppBash...

Seriously IDEs are great! I don't understand people on Slashdot who think if its not hard, its not worthy!

That's a bit of a strawman. IMO, the real issue is that people see it as a false dichotomy between a good text editor (Vim, Emacs, etc.) and a kitchen sink of tools attached to something little better than Notepad with syntax highlighting + autocompletion (e.g. Visual Studio). In that comparison, the text editors win because the vast majority of programming comes down to text editing (and possibly thinking, but you don't need a computer for that), and typical IDEs are pretty mediocre at that.

Note that it's a false dichotomy - you can get the benefits of both, either by integrating a proper text editor into your IDE (e.g. Eclim adds Vim to Eclipse) or by adding many plugins to your text editor - I use Vim with 53 plugins, and I have every feature on your list (although hovering over a variable is replaced with typing a shortcut while the cursor is over it). You only need about 10 to get most of the benefits though, especially if you only work with one or two languages.

Arduinos can get by with as little as 5 uA in standby:

https://github.com/petervojtek...

Part of long battery life is also to have an OS that allows the system to sleep most of the time.

A Spec mote takes a few cubic millimeters of space. Those are the kinds of specs we're heading for, and a 1000x difference in memory and the nature of the OS matter a great deal. Android doesn't cut it.

That may show things like the only 3 IoT devices in my house being hard wired and thus no one could care less if they use 1uA or 320000 times more power.

You're confusing cause and effect: the reason they are all hardwired is that getting things to be low-powered is tricky.

I have dozens of IoT devices around my house, and they are almost all battery powered. They also last at least a year each. Even cameras are moving to battery power now, making installation much easier. Ideally, eventually, they will be lower power enough so that they can run on light or beamed power.

Are you using AdBlock Plus for Firefox or uBlock? ABP might be a little too intensive for a mobile CPU and you might be better served with uBlock on your phone. I personally use uBlock on Firefox for Android and I don't have any performance issues, but that's just me.

(proof that torvalds actually uses C++ if anyone hasn't seen that: https://github.com/torvalds/su... [github.com])

Linus never said he wouldn't write or contribute to projects written in C++, he said the C++ language is inappropriate for kernel code. No more, no less.

Back on topic, I have been in programming and systems administration professionally for over 35 years, and the Java that exists in the field today is generally the worst performing, most overwrought code I've ever seen. This is not necessarily meant to be a criticism of the language, but rather of the programmers that write in it. It's said that a good programmer can make good code in any language, but Java programmers consistently produce expensive, underperforming garbage that is easily replaced with cheaper, faster code written in nearly any other language (even BASIC or PHP!).

On a slightly more serious sidenote, it's easy to see Java's popularity dropping, since Google seems to be dumping java for high performance javascript/dart development, as they have already been announcing for Android.
http://arstechnica.com/civis/v...

Linus has actually stated it in a way that is frequently seen as toxic. But, while C++ is one of my favourite programming languages, certain language features tend indeed to "rotten" people's brains, just like pre-GIT CVS+derivatives did to source control habits. And I find that Java is actually the perfect representative of that nowadays, not C++ (and even Linus is now commiting patches in C++) I don't know what you guys people but when I have to traverse a tree of 10 folders, and files have 10 lines and exist only for a single abstraction's sake, I kinda feel OOP, though a powerful tool, has been overused. When everything has to be an object just for a paradigm's sake, things can get kinda distorted. One of the greatest programming innovations is, in my opinion, MVC (or even MVVC stuff like Angular) is one of the greatest things that have been getting popular lately. By separating logic from models and views people are encouraged not to create stupid abstractions and use procedural programming where it is adequate and avoid performance losses.

(proof that torvalds actually uses C++ if anyone hasn't seen that: https://github.com/torvalds/su...)

The non-overloaded code has a readability problem, I agree. But for example the Scala Built Tool, SBT, has operator overloading abused to hell and it makes complex build files useless to read for all but really experienced SBT users. The XML-driven Java build tool Maven, the Groovy-driven Java/Groovy build tool Gradle, and the Clojure-driven Java/Clojure build tool Leiningen are all much easier to read. Though to be fair, Groovy supports operator overloading, the Gradle team just chose not to abuse the feature for build management.

Look at some SBT examples, for example https://github.com/playframewo... In that file we have %, +=, :=, , none in a mathematical context, all on top of normal Scala operator syntax =, ==, =>, _, etc... I'm surprised I didn't see ")*&%()*$&%&&*XR&R^NO CARRIER" at the end of the file.

Actually, since RequestPolicy stopped working in my Iceweasel, I installed Policeman. It provides a neat UI for selecting precisely which sites can load what from where, including options like loading styles but not scripts. I believe NoScript is necessary to block firsthand scripts, however.

Two things -

• * First, (as you already know) your numbers checked out. I evidently suffer from an off by one error in my head here, which I find fascinating because this isn't zero-indexed.
• * Second, I'm all for a system that would charge 33 554 431 for 25 years of copyright. The system is only supposed to work so long as a work is profitable enough to merit it, and such a system would force copyright holders to actual make risk//reward assessments in real time instead of taking it for granted that they can beat the horse for money forever.

You may find the code used to check prices here; it is only known to work for the first 31 years (the limits of a signed long on my architecture).

According to an article in Spiegel Online three of the engines shut down during takeoff.

The fatal crash of a brand new A400M military transporter was found to be caused by technical issues. According to information from SPIEGEL ONLINE, three of the aircraft's engines were shut down due to software problems, directly after takeoff.

The cause of the crash of a brand new type A400M military transport aircraft appears to have been identified. According to information from SPIEGEL ONLINE, the engineers from Airbus Military discovered a software problem in engine control unit, that supposedly caused the simultaneous shutdown of three engines.

The investigation produced a clear result: Shortly after the test aircraft took off, the three engines had received conflicting commands and subsequently cut all power.

The pilots, who were testing the A400M, could not have done anything, according to Airbus sources. They still attempted to steer the 45m long plane back to the airport in Seville, but could not control it any more. The aircraft struck a power pole, slammed into a field and burnt completely.

There were also claims that much of the software was written by underpaid inexperienced developers and there was high turn over due to a high pressure environment.

Has anyone considered Joyent's Manta ?

This is a distributed object storage with integrated compute.
Data is stored on a cluster of SmartOS hosts..
And processed directly on each host inside a OS container (SmartOS zone), no data movement.

Lot of APIs available: R, command-line, python, ruby, node.js etc..

Available on their cloud and as a on-premises commercial product, opensourced last November (simulteanously with smartdatacenter).

As for licensing, The vast majority of contributors have been contacted, and responses are trickling in. In general the responses seem split across "I don't care", "GPLv2", and the stock BSD 3-clause that we're hoping to move toward. You can keep track of the ongoing per-source-file relicensing on MAME/MESS's Github page here: https://github.com/mamedev/mam...

As someone who contibuted to the MESS code over 10 years ago, I'll say that I can't even recall exactly what code I touched, or if my changes even still exist. And other than this note, they'd have pretty much no way to contact me, as my old addresses lapsed years ago. But I have no problems with a more libre license; I just can't quite figure out how they could possibly pull off moving to one, as there must be many other minor code contributors like me out there.

https://github.com/mamedev/mame/blob/master/docs/licenseinfo.txt

Grant Galitz's browser-playable versions of GBC and GBA are light years ahead of the emscripten version of the MESS code for those. Any chance they can be used?

Grant Galitz's browser-playable versions of GBC and GBA are light years ahead of the emscripten version of the MESS code for those. Any chance they can be used?

The issue tracker in Rust is used not only for bugs in the compiler, but also for tracking the standard library, new features, enhancements, some infrastructure, documentation, lints, etc. Assuming that 1900 open issues means there are 1900 bugs is ridiculous. If you look at the labels used on the issues tracker, you'll find that the label I-crash has 19 open issues. Of course not all bugs will be labelled correctly, so no doubt there will be more defects, but hardly the number that the 'worried' anon suggests. Also note that the language has changed significantly over the years, until it reached the current design. To look at some of the older bugs and conclude that the current version of the language can't be very good is silly because the rust of two or three years ago might as well have been a completely different language. As for servo, looking again at the label I-crash, I see (at this time) 39 open issues, which sounds much more reasonable than 800.

The issue tracker in Rust is used not only for bugs in the compiler, but also for tracking the standard library, new features, enhancements, some infrastructure, documentation, lints, etc. Assuming that 1900 open issues means there are 1900 bugs is ridiculous. If you look at the labels used on the issues tracker, you'll find that the label I-crash has 19 open issues. Of course not all bugs will be labelled correctly, so no doubt there will be more defects, but hardly the number that the 'worried' anon suggests. Also note that the language has changed significantly over the years, until it reached the current design. To look at some of the older bugs and conclude that the current version of the language can't be very good is silly because the rust of two or three years ago might as well have been a completely different language. As for servo, looking again at the label I-crash, I see (at this time) 39 open issues, which sounds much more reasonable than 800.

The issue tracker in Rust is used not only for bugs in the compiler, but also for tracking the standard library, new features, enhancements, some infrastructure, documentation, lints, etc. Assuming that 1900 open issues means there are 1900 bugs is ridiculous. If you look at the labels used on the issues tracker, you'll find that the label I-crash has 19 open issues. Of course not all bugs will be labelled correctly, so no doubt there will be more defects, but hardly the number that the 'worried' anon suggests. Also note that the language has changed significantly over the years, until it reached the current design. To look at some of the older bugs and conclude that the current version of the language can't be very good is silly because the rust of two or three years ago might as well have been a completely different language. As for servo, looking again at the label I-crash, I see (at this time) 39 open issues, which sounds much more reasonable than 800.

To add, unlike Swift Rust has been publicly being developed on Github since 2010. So it doesn't matter what anyone "says" when there is a Public git record dating back to their 2010 public announcement about the language. Unless you think Github and the Rust developers faked their git history.

I've very worried about what I'm seeing with Rust.

The Rust web site says very clearly

Rust is a systems programming language that runs blazingly fast, prevents nearly all segfaults, and guarantees thread safety.

Yet when I look at the GitHub issues list for the Rust compiler and standard library, both of which make extensive use of Rust, I see over 1900 open issues and over 11500 closed ones.

When I look at the GitHub issues list for Servo, which also makes extensive use of Rust, I see over 800 open issues and over 1500 closed issues.

The Rust compiler and standard library are being created by the people who know Rust the best. Some of these people are also involved with Servo. Both are the largest real-world Rust projects I know of, too.

If Rust is allegedly so much safer to use, why do projects developed using it, written by some of the best Rust experts around, have so many bugs? If those who know the language inside and out can't write code that's any less buggy than code written in other languages, how are the rest of us normal programmers supposed to ever write good code in Rust?

I'm worried because Rust is going to give a false sense of security and quality to too many people. They'll think that by using Rust they'll avoid bugs, when as existing large projects developed in Rust by Rust experts clearly show, that just isn't the case. For a language that's supposed to make creating buggy code harder, Rust isn't doing a good job at all at preventing bugs.

I've very worried about what I'm seeing with Rust.

The Rust web site says very clearly

Rust is a systems programming language that runs blazingly fast, prevents nearly all segfaults, and guarantees thread safety.

Yet when I look at the GitHub issues list for the Rust compiler and standard library, both of which make extensive use of Rust, I see over 1900 open issues and over 11500 closed ones.

When I look at the GitHub issues list for Servo, which also makes extensive use of Rust, I see over 800 open issues and over 1500 closed issues.

The Rust compiler and standard library are being created by the people who know Rust the best. Some of these people are also involved with Servo. Both are the largest real-world Rust projects I know of, too.

If Rust is allegedly so much safer to use, why do projects developed using it, written by some of the best Rust experts around, have so many bugs? If those who know the language inside and out can't write code that's any less buggy than code written in other languages, how are the rest of us normal programmers supposed to ever write good code in Rust?

I'm worried because Rust is going to give a false sense of security and quality to too many people. They'll think that by using Rust they'll avoid bugs, when as existing large projects developed in Rust by Rust experts clearly show, that just isn't the case. For a language that's supposed to make creating buggy code harder, Rust isn't doing a good job at all at preventing bugs.

Usurper was ported to Win32 (a few times), a bunch of bugs have been fixed, maintenance has been optimized, etc. https://github.com/rickparrish... has the updated source

You originally claimed that method interception only works in "message passing" systems. I disagreed and explained why it is wrong.

I did not claim this at all. I claimed that without a virtual machine it can't be done with vtable dispatch, unless you use compile time weaving or evil.

I then explained how Spring and Hibernate use byte-code generation (the cglib library) by hooking the class-loader to provide method interception. This is different than load-time weaving, which uses a JVM agent. Spring supports both, and both require a virtual machine in any case, which was my point.

Further, my point was that although Swift supports messaging as an interop to Cocoa, 'pure' Swift uses inlining, static or vtable type dispatches. And without a virtual machine this means foregoing runtime instrumentation of classes. Its a drawback that deserves more attention.

But you might want to look at groovy and see how it is done there, as you don't need a class weaver/weaving class loader there.

That's right. As we have just discussed cglib, which is built on top of asm (confusing name - has nothing to do with assembly language) hooks the classloader, so that it looks for method interception rules and emits a runtime generate subclass. This is called byte-code generation. Another library for this is Javassist.

I stand corrected on method symbols and static/vtable dispatch.

You originally claimed that method interception only works in "message passing" systems. I disagreed and explained why it is wrong.

I did not claim this at all. I claimed that without a virtual machine it can't be done with vtable dispatch, unless you use compile time weaving or evil.

I then explained how Spring and Hibernate use byte-code generation (the cglib library) by hooking the class-loader to provide method interception. This is different than load-time weaving, which uses a JVM agent. Spring supports both, and both require a virtual machine in any case, which was my point.

Further, my point was that although Swift supports messaging as an interop to Cocoa, 'pure' Swift uses inlining, static or vtable type dispatches. And without a virtual machine this means foregoing runtime instrumentation of classes. Its a drawback that deserves more attention.

But you might want to look at groovy and see how it is done there, as you don't need a class weaver/weaving class loader there.

That's right. As we have just discussed cglib, which is built on top of asm (confusing name - has nothing to do with assembly language) hooks the classloader, so that it looks for method interception rules and emits a runtime generate subclass. This is called byte-code generation. Another library for this is Javassist.

I stand corrected on method symbols and static/vtable dispatch.

Aside from LUA I don't think TCO has ever mattered much. It won't matter for Rust either.

In any case, TCO isn't off the table for Rust. They haven't blessed it yet, but they are deliberately not precluding it as the language evolves.

Nothing speaks agaisnt a vm-less, class loader less, vtable based, method dispatch WITH reflection and introspection.

Sigh. I agree with this, but point out that C++ and Swift don't provide these, and that vtable dispatch creates an array of method pointers, and unlike objective-c, does not preserving the method names. This information has to be added on separately. Java 1.0 didn't include reflection. Even if I was mistaken in this, there is no need to start making personal insults and calling this "retarded".

Important (for you):I think you might be missing the point about method interception. Are you familiar with this concept? In Objective-C we call this method swizzling. You can either swizzling the look-up table for a method (modify all instances) or change the isa pointer for a class - modify a single instance.

In the Objective-C community, swizzling is misunderstood to be a hack, but it affords all kinds of useful features, such as Cocoa's elegant property observers, Core Data managed objects and such.

People also misunderstand that this has nothing to do with introspection and dynamic invocation. In Java we can do the following:

• * Before a class is emitted from the class-loader, emit a run-time generated sub-class, where methods are proxied in the same way as above. Libraries like asm, cglib and javassist do this. Spring uses cglib to proxy concrete classes and provide AOP such as declarative transaction management and security. Hibernate uses it to provide 'managed objects'

• Er, to emit a runtime generated sub-class of a class, just prior to it being loaded, does require a class-loader, which in turn requires a JVM. Many people outside the Java community don't relaize this, but it gives most of the benefits of Objective-C's (messaging) late binding, although it does not allow arbitrarily adding new methods to a class.

  I do know something about Java, having made some contributions to the framework that revolutionized enterprise development, and going on to teach it around the world. Later I created my own framework to help Objective-C developers implement a design pattern that is well understood among Java developers.

  I enjoy discussion, I'm open to being corrected if I make a mistake, but if you would like to revert to childish insults then I don't have time to participate. I'm interested in sharing my knowledge and learning new things.

* Object introspection - describe the methods and properties of an object * Dynamic invocation - reflectively invoke methods of an object. * Method interception - add or reroute methods for all instances or a single instance of an objection, optionally calling the original.

All that has nothing to do with "message passing".

You think so?

Runtime method interception is supported in languages that use vtable style dispatch rather than messaging, only because these languages feature a virtual machine, and class-loader. Otherwise the function-pointers are compiled right in. It is not possible to perform method interception without evil. With Objective-C we can perform method swizzling - modify the lookup table to resolve methods to a function pointer) or isa swizzling - change the 'class', to a dynamically generated one, for a given instance at runtime. Cocoao's property observers use this. Its not possible without messaging. This is why AOP frameworks for C++ are compile time only.

Object introspection & dynamic invocation : When methods are in-lined, statically dispatched or vtabled we can't reliably dynamically invoke a method. Even with the most flexible of these three, vtabling, we're still stripping the function name out so that its replaced with something like 'method[3]'. It doesn't have to be like this, but it is for C++ and Swift follows suit.

They are learning:
allwinner-zh
Are any of the other SoC vendors any better?

Javascript developers think they're amazing (Javascript 760000, followed by HTML at a measly 323)
https://github.com/search?utf8...

I hate and mistrust Microsoft as much as the next guy, but let me say this:

* Mathematics is powerful because you take two numbers and an operator and as a result you get something that you can re-use in the same fashion

* Unix is powerful because you take text files and an operator and as a result you get something that you can re-use in the same fashion

* Relational DBMSs are powerful because you take two relations and an operator and as a result you get something that you can re-use in the same fashion

* Monad Shell (now called Power Shell) is powerful because you take object streams and an operator and as a result you get something that you can re-use in the same fashion

A Monad really is something where you put (typically) a constant into a function and get out a specialised function (like, you put 5 into your Monad and out comes a function that takes an integer and returns that same thing plus five).

The Unix world has Perl Shell, Python Shell, and something that the Power Shell is a copy of, the Haskell Shell.

https://github.com/chrisdone/h...
http://www.yesodweb.com/blog/2...

Best regards,

Oliver

Some of my favorites:

Dear God Why?
https://github.com/search?utf8...

Ugly as sin (Javascript wins, C a close second)
https://github.com/search?utf8...

"BUG" (Holy God, 52 million entries in C, Javascript has 5.4m in second)
https://github.com/search?utf8...

TODO (20.9 million C entries, 7 million on PHP in second)
https://github.com/search?utf8...

FIX (24 million C entries, 6.3 Javascript in 2nd)
https://github.com/search?utf8...

"Why does this work?" (C, 2.9 million, C++ 307,942 in 5th place)
https://github.com/search?utf8...

"What does this do?" (C, 10.9 million, C++, 1 million in 5th place)
https://github.com/search?utf8...

One would probably have to divide those results by actual number of files in that language to get a percentage. You also might want to control for code complexity. But if we were gonna be quick and lazy, I would guess C uses more hacks/obscure code to get the job done and when that veteran leaves, nobody knows what it does.

On the bright side, C/C++ look like they tend to have tons of comments which (as long as they don't rot) is a very good thing. And if you're describing "why" and not "how" with comments, those will rarely rot.

Some of my favorites:

Dear God Why?
https://github.com/search?utf8...

Ugly as sin (Javascript wins, C a close second)
https://github.com/search?utf8...

"BUG" (Holy God, 52 million entries in C, Javascript has 5.4m in second)
https://github.com/search?utf8...

TODO (20.9 million C entries, 7 million on PHP in second)
https://github.com/search?utf8...

FIX (24 million C entries, 6.3 Javascript in 2nd)
https://github.com/search?utf8...

"Why does this work?" (C, 2.9 million, C++ 307,942 in 5th place)
https://github.com/search?utf8...

"What does this do?" (C, 10.9 million, C++, 1 million in 5th place)
https://github.com/search?utf8...

One would probably have to divide those results by actual number of files in that language to get a percentage. You also might want to control for code complexity. But if we were gonna be quick and lazy, I would guess C uses more hacks/obscure code to get the job done and when that veteran leaves, nobody knows what it does.

On the bright side, C/C++ look like they tend to have tons of comments which (as long as they don't rot) is a very good thing. And if you're describing "why" and not "how" with comments, those will rarely rot.

Some of my favorites:

Dear God Why?
https://github.com/search?utf8...

Ugly as sin (Javascript wins, C a close second)
https://github.com/search?utf8...

"BUG" (Holy God, 52 million entries in C, Javascript has 5.4m in second)
https://github.com/search?utf8...

TODO (20.9 million C entries, 7 million on PHP in second)
https://github.com/search?utf8...

FIX (24 million C entries, 6.3 Javascript in 2nd)
https://github.com/search?utf8...

"Why does this work?" (C, 2.9 million, C++ 307,942 in 5th place)
https://github.com/search?utf8...

"What does this do?" (C, 10.9 million, C++, 1 million in 5th place)
https://github.com/search?utf8...

One would probably have to divide those results by actual number of files in that language to get a percentage. You also might want to control for code complexity. But if we were gonna be quick and lazy, I would guess C uses more hacks/obscure code to get the job done and when that veteran leaves, nobody knows what it does.

On the bright side, C/C++ look like they tend to have tons of comments which (as long as they don't rot) is a very good thing. And if you're describing "why" and not "how" with comments, those will rarely rot.

Some of my favorites:

Dear God Why?
https://github.com/search?utf8...

Ugly as sin (Javascript wins, C a close second)
https://github.com/search?utf8...

"BUG" (Holy God, 52 million entries in C, Javascript has 5.4m in second)
https://github.com/search?utf8...

TODO (20.9 million C entries, 7 million on PHP in second)
https://github.com/search?utf8...

FIX (24 million C entries, 6.3 Javascript in 2nd)
https://github.com/search?utf8...

"Why does this work?" (C, 2.9 million, C++ 307,942 in 5th place)
https://github.com/search?utf8...

"What does this do?" (C, 10.9 million, C++, 1 million in 5th place)
https://github.com/search?utf8...

One would probably have to divide those results by actual number of files in that language to get a percentage. You also might want to control for code complexity. But if we were gonna be quick and lazy, I would guess C uses more hacks/obscure code to get the job done and when that veteran leaves, nobody knows what it does.

On the bright side, C/C++ look like they tend to have tons of comments which (as long as they don't rot) is a very good thing. And if you're describing "why" and not "how" with comments, those will rarely rot.

Some of my favorites:

Dear God Why?
https://github.com/search?utf8...

Ugly as sin (Javascript wins, C a close second)
https://github.com/search?utf8...

"BUG" (Holy God, 52 million entries in C, Javascript has 5.4m in second)
https://github.com/search?utf8...

TODO (20.9 million C entries, 7 million on PHP in second)
https://github.com/search?utf8...

FIX (24 million C entries, 6.3 Javascript in 2nd)
https://github.com/search?utf8...

"Why does this work?" (C, 2.9 million, C++ 307,942 in 5th place)
https://github.com/search?utf8...

"What does this do?" (C, 10.9 million, C++, 1 million in 5th place)
https://github.com/search?utf8...

One would probably have to divide those results by actual number of files in that language to get a percentage. You also might want to control for code complexity. But if we were gonna be quick and lazy, I would guess C uses more hacks/obscure code to get the job done and when that veteran leaves, nobody knows what it does.

On the bright side, C/C++ look like they tend to have tons of comments which (as long as they don't rot) is a very good thing. And if you're describing "why" and not "how" with comments, those will rarely rot.