skysight-inc/HackerNews huggingface dataset:
Yea I'm mostly agreeing with you. I just mean numbers wise it might not be strictly impossible to do (except in places where you get >2" of snow, in which case it might actually become strictly impossible). I make no claims towards its feasibility :P

Not that they provided any actual data for us to tell if it is impossible or not.

Edit: hell, they don't even make a cost comparison to putting regular old solar panels next to the road, instead of baked into the road, and using the energy from that to do whatever fancy shit.
>The point is that they believe they can.

They are welcome to believing that, just as the Catholic Church is welcome to thinking I'm going to burn in hell for all eternity for not believing their god.
"Free. No Ads." What's the business model - who is paying for it and why? Will my files be around a month from now when you move on to something else?
Legit devices have had duplicate Mac addresses even though they're not supposed to. In practice a totally random MAC is probably safer than the one assigned to a cheap network card.
How does a language win? By being compelling enough to be used for new things. It's not solely a technical concern; it's a concern of the language community and ecosystem.

One of the most valuable 4 sentence paragraphs I've read from an HN post in awhile. (Perhaps 3, but the semicolon really separates 2 sentences.)
I've worked for a company (electronics design/installation) that desperately underbid competitors to get as many jobs as possible, then the boss piles pressure on the workers to get the job done at an inhuman speed. Inevitably, up fucks occur and the boss has a shit fit, you get in trouble and have a black mark against your name. Not fun all around.

The lessons, not every job is worth doing and always allow margins for mistakes.
I've actually thought about ocaml myself, but one silly thing keeps putting me off. It feels like typing "let" over and over again would drive me crazy!

I guess it's not that bad after looking at this for example:

https://github.com/0install/0install/blob/master/ocaml/zeroi...
But as was mentioned in another comment, what you mention as a key appeal for sysadmins is exactly why I can't stand perl. In particular "extremely flexible syntax" makes taking over the sysadmin job from another person, or joining a team, a ridiculous amount of effort. I can't begin to tally the number of hours I've spent with perl code open in one window, and a web browser open to various different perl guides, the documentation, etc. trying to figure out what tricks some script is using that makes it completely incomprehensible to me.

Is it fun? Sometimes, except never when a key service is down and you have users breathing down your neck. Or your website is down. Or really, trying to do any kind of maintenance work. And guess what happens? More crazy patches, probably written in an entirely different style! So now there are $n+1$ different styles in that script, and my successor is going to be even more frustrated with me than I am with my predecessors.

On the flip side, it's been a great education on the difference between maintaining code for your own use and code in an organization...
3K Later
Action extensions are essentially share extensions with a return value. They may or may not present UI, and then manipulate content before returning it to the running application. For example, a Bing translate action can be run on a webpage.

Extensions cannot be enumerated or run programmatically using public APIs. They can only be presented after user interaction in a presented UIActivityViewController.
>> What Killed Perl?

The article is entitled "Why Perl Didn't Win", not "Why Perl is Dead". Perl hasn't been killed.
If being nice was a prerequisite for being right everyone from Socrates onwards is wrong.
Govt. spending: atlassian and open source do not exist
M64.pl – how I learned that the default settings are not production settings
> Swift’s type system is best described as “way better than Java’s”, or perhaps “far more comprehensible than Scala’s”

I love Scala's type system, so I'm looking to seeing if Swift's really is better. Any type system is better than none at all - probably why most javascript-heavy apps become nightmares when they get to be > 1000 LOC.
Microsoft buys their gear..?
I got introduced to Perl in 2006, at a time when trolls were screaming 'Perl is dead' from top of the buildings. Perl was revolutionary to some one like me who had only done C and assembly language programming. And it turned to be a great tool for the job back then(Processing massive unstructured text files). Its still unbeatable in that area.

Back then I saw that people who worked around enterprise projects that used some kind of a relational database used a lot of Java. People who were jumping to the Web 2.0 Bandwagon, used stuff like Python and Ruby largely because of the frameworks. Thereby what's really apparent is tools that are best suited for the job get traction.

Perl is still unmatched for many things. Unixy things like dealing with large quantities of text. Gluing things together, getting stuff done quickly etc etc.

Perl's every day use cases were going way, as database and web heavy things ruled the business scenarios. Perl largely occupied a niche and ruled it. So is Python today(Web frameworks), and ruby. Also Perl reached a very high peak in the 90's. And reaching that kind of level again isn't possible unless Perl does some very new and paradigm changing.

Perl 6 is kind off believed will do that eventually some day. But from what I last heard a few day back in this very forum, there are not close to anything serious even in another 2 years from now.
"Any type system is better than none at all"

For tiny things, I profoundly disagree. A great type system is still (IMO) better than none at all, but there are plenty of type systems that get in the way more than they can be pressed into helping especially when things are tiny. When things are large, it's there are probably still some pathologically unhelpful type systems, but there's generally more leverage to be had...
Depends what you're selling. A grocery store is like that since they operate on razor thin margins and making you impulse buy is how they are going to make more money.

An Apple store is not laid out like that. I always see the big ticket items upfront and the accessories in the back. Most people don't impulse buy things that expensive.
""non-standard" bits of the language start leaking into your code"

I work on a small team (C++), so this has never been an issue. If you break coding guidelines someone will notice and let you know.

But this really should be integrated into work-flows. (ie/ into Gitlab, Jira, etc.) There should be some kind of step - before you are allowed to merge code - that checks that you are withing coding guidelines.
>bit on the paranoid side
Not at all. Probably saves battery too.
In one sentence, subtly hinting that there's no possible way you could be wrong and comparing yourself to the great philosophers.

While impressive self-aggrandizing, in no way did I say "be nice" and that's a pretty disingenuous reading of what I wrote. You could have made your point without the little left hook in your text without trying to be nice.

Since you're arguing with me on something I consider to be readily apparent, I can mostly figure out that I'm wasting my time. (And, also, I have a hard time imagining Socrates responding to "I can't see your point of view" with "that's because you're not using your brain, dumbass.")
The weather is much nicer in the Bay Area, and people don't look down on you if you are living on ramen while your investment bank buddies are raking it in.
> But it's a rotten language to maintain.

I've been diving into some of our legacy Perl and man, the learning curve of the various sigils and implicit variables. Even working with collections was challenging.

I'm working to make it better Perl (I have a copy of Modern Perl on my desk), but that's solely to make it understandable so that we can rewrite it / replace it with something like Salt.
> work well with the steam controller on the Linux box and would drive sales to the Steambox.

I am a gamer on Linux, but there's no reason these games will run better on Linux vs Windows or use the controller better (since they will probably support the controller drivers for Windows systems as well). Valve has repeatedly said they would not do any exclusive titles for any platform as well, so I don't think just a couple of great games will drive much Steambox sales. There are going to be several drivers for Steamboxes: 1) the hardware needs to be cheap enough 2) the experience needs to be seamless and AS GOOD as a console if not more 3) enough big games to ensure you do not miss too much by not staying on Windows.
It's a process. iOS 4 opened the limited multitasking APIs, and iOS 7 allowed any app to refresh in the background. I predict the same for extensions, except on an accelerated schedule.
Perl is sort of like trying to read someone else's brain (in this case Larry Wall's). You get themes and kind of the gist of where it's going, but it never quite adds up to some sort of coherent whole.

The defense has always been that Perl is designed more like natural language than programming language, ok, but: natural languages are a LOT harder to learn than programming languages. Put me in a room with Haskell and I'll learn it in a month. Give me a month of training in french and I'll maybe be able to not make an entire ass of myself if I try to get from point A to point B. Human languages are hard. Design wise -- I'm not sure that's what you want to aim for.

Almost everything you learn is... surprising. Like flattening lists. Useful in a context, maybe, but is that the kind of thing anyone would ever expect? And why is "list" (@) part of the variable name in the first place? It's like "dynamically typed, kind of, except your variable name has to say if it's one thing or many things or many things referenced with keys". What the fuck? I'd rather the python way of "it's a name that points to a thing, whatever that thing is". GOT IT. Simple.

I program in C++ for a living, probably the biggest clusterF of a language ever devised (outside of perl), and the thought of reading Perl still terrifies me.
Religion as a Product of Psychotropic Drug Use
For tiny things, sure. But tiny things tend to grow over time
>Engineering the Extinction of 40 Species of Mosquitoes

Hmm, to me it sounds like:

Screw science (which takes time), let's apply half-learned stuff in real life instead and see what sticks.

E.g let's apply what little we know to extinguish mosquitoes we don't like, despite not fully knowning the ecological consequences of our actions. Hopefully we won't have to deal with the mess (or there won't be a mess).

After all we did something similar before. If you do something once and it turned out OK, then even if you don't understand it, it will always come out OK in any other context, right?
Hm, that doesn't sound too bad. Do you say a certain extension "implements" a certain type of action or something? E.g. the Bing translate implements "com.apple.action.translate.web" and thus when Safari asks for actions that implement "com.apple.action.translate.web" Bing translate appears to the user, or Zxing implements "org.moreactions.scan.barcode" so then when the user taps "find by barcode" in a shopping app the Zxing app is presented to them as a choice?
It's certainly possible to write functions (subs) with comments about what they do, and use meaningful variable names in Assembly too.
Google's Chrome Gmail encryption extension hides NSA-jabbing Easter Egg
>Does the fact that we have done this thousands of times now, accidentally, without any knowledge of the species being affected, make it any better?

It sure does not. After all, tens of thousands of species have gone extinct in our watch. Who knows how many of those were due to having done "this".

>Does the fact that essentially all of the interspecific dependencies in the temperate and Arctic zones have shifted completely in response to simple climate change since the last glaciation, make it any better?

Nope. And I seriously doubt they have shifted "completely".
Exactly. Plus, I think Apple is (quite reasonably) concerned about the potential privacy and security risks posed by malicious extensions, and so is intentionally minimizing the available surface area, and some aspects of functionality in order to mitigate threats.
Will this work?...And it did. Close to zero cognitive overhead.

This notion of cognitive overhead (or any other kind of overhead) and how it scales (as programs get larger, applications get older, and/or systems become more interconnected) is really what's important to language and system design.

Yet most of what gets bandied about between programmers seems to involve what is nifty or what can save you some kind of overhead on mostly rather small scales. Even if a library or language feature can save you from typing another line of code 1200 times throughout a project, that doesn't necessarily mean it's a no-brainer. Ask yourself: What other kinds of costs are incurred? If your nifty doodad increases compile times by a factor of 10, or completely kills the cache across large parts of your application, or makes large swathes of the code hard to debug, it may not work out cost-benefit wise.

So, that's why I left Perl - Readability and complexity of what should be bog simple data structures.

Ironic in the Alanis sense, because one thing that drew me to Perl in the first place was the bog simple use of Dictionary, as compared to writing the same thing in C.
I can't talk about the comparison to perl/python/ruby, but yes, using the triple dot includes the upper limit, and using the double-dot excludes it. For the typical (for var i=0; i < count-1; i++) scenario, you'd using the double dot (i in 0..count).
Wow, what a difference. Thanks!

Submitted url was http://news.yahoo.com/report-chinese-company-faulted-bridge-....
In one of the WWDC sessions an Apple engineer was adamant one should never choose terseness over clarity, because every line of code is written once by one person, but read many times by many people.

And funny enough Objective-C is taking this quite seriously, being a very verbose language (the new Swift language also keep the verbose method names, enums and properties).

While Perl is exactly the opposite. There's a reason people jokingly call it a write-only language.

It has real implication on its usage. You use Perl for one-off scripts you intend to forget and maybe delete after you run them a few times.

While CPAN happened, I wonder how much Perl was an obstacle in multiple people joining to work on a single library (versus multiple people just downloading it and using it, big difference).
We haven't had a business model yet. We just want to build something our family and friends want to use.

Those files are there until you delete them yourself. You decide.
Ask HN: Why can't I find work with a well-documented code base?
I've been at a variety of places. Some startups, some star companies you've heard of. Yet at each of these places, the documentation is minimal, the code is terribly written with tribal knowledge needed everywhere, and management keeps aggressively trying to push out features before they're ready. Have I just been getting bad luck here? Or is well-written, well-documented, well-tested code something that doesn't really exist?
Yes. But replacing the entirety of something tiny shouldn't be hard. One just has to do it, which involves 1) knowing to, and 2) following through.

Of course, best case is an awesome type system and libraries that suit your problem.
Snowden was targeted by Russian spies 6 years before he exposed US secrets
If this article had been written about natural languages, it might be called "Why French didn't win". It may not be the world's most popular language, but it's extremely useful to a lot of people.

Winning isn't everything. :)
about California's 40% of population have East Asian race affiliation and current voting system unfairly favors such non-uniform population distribution. Immigrants arn't merely confined to ironing your shirts and preparing dim sums, but they're taking over 'important' positions like elected officials.

most of such third-world nations don't have a grasp on essentials ideas for functioning, sustainable society (like transparency). It is not a surprise that a Chinese-ridden state picked some suspicious Chinese company for a multibillion dollar project, costing non-Chinese taxpayers $$$.
I always check on indeed.com to confirm the popularity of things. It looks like Python just broke past Perl on absolute job posting numbers.

http://www.indeed.com/jobtrends?q=+perl+developer%2Cpython+d...
That's what I said. Swift is a subset of F#/Scala.
Seems the fact that the company was Chinese is pretty irrelevant - and yet it's repeated over an over.

China is the new bogeyman.
Regexes are actually a great example of a tool that makes it easy to write code that is difficult for you to fully understand later.
Your reply makes no sense to me I'm afraid.

> And I didn't realize the well written Perl code compiles equally better.

Equally better?

> And its certainly a lot easier to open files and do things in Perl than writing several hundreds of lines just to set and get variables for one single class.

Come on, seriously. Here's how I open files in Java:

import com.google.common.io.Files;

List<String> lines = Files.readLines(new File("/foo"), Charset.UTF8);

Why do you insist on straw-men to back up your arguments?
--- Java ---

List <Integer> aList = Arrays.asList( new int [] { 1, 3, 5 }); // probably missing some more type stuff in <>

Map <String, String> aMap = new HashMap <String, String> ();

aMap.put( "name", "Joe");

aMap.put( "ID", "42"); // I need to check if Java 8 has map literals a la Groovy...

doSomething( aList, aMap);

...

void doSomething( List <Integer> aList, Map <String, String> aMap) {

System.out.println( "First: " + aList.get( 0) + ", Name: " + aMap.get( "name") );

}

--- Perl ---

&do_something( [ 1, 3, 5 ], { 'name' => 'Joe', 'ID' => '42 });

...

sub do_something {

my( $list_ref, $hash_ref) = @_;

printf "First: %d, Name: %s\n", ${ $list_ref }[ 0 ], ${ $hash_ref }{ 'name' };

}

------

I'm not seeing that much of a difference in parameter passing, other than the explicit reference/dereference syntax.

Of course Java doesn't require 500 line methods. But the bondage and discipline imposed is independent of whether or not readable code will be produced.

I actually like strongly typed languages for larger programs, but prefer something more fast and loose for smaller ones. TMTOWTDI!
I think they should be enforceable only as long as the company is paying you. So they can either keep paying you and keep you from competitors, or they can waive the non-compete, but they can't keep you out of the job market for free.
Not on the iPhones and Android phones of the people whose names are consistently correctly displayed on the dashboard. The MAC address had to be entered into the dashboard software manually, but no interaction was required on the phone whatsoever.
This sort of distinction exists in other languages though: Java has == and equals. OCaml has = and == etc. (Not that Perl doesn't have its issues; but this is very low in that list imho)
There is more data, thought and science in this than in many journal articles I've read.
Everything Learned In One Year Of Unprecedented Top-Secret Leaks
Modern WebScript Syntax (1996)
OP here. This was just a little module that I found very useful in quickly exploring large, unfamiliar SQL databases and their associated business logic.

It's fairly rudimentary feature-wise, but has worked well for me. Happy to answer any questions.
I recall reading an article that claimed the uptick in Alzheimer's is simply due to a larger percentage of people living long enough to get it.
pdf for download here: http://papers.ssrn.com/sol3/papers.cfm?abstract_id=2022822
The question I have is how different the solar roadways, designed with this in mind, would behave from running heating elements through concrete or asphalt? Could they get an order of magnitude difference?
I'm okay with them, actually, but only as long as the company is still paying you the same wages. I think this condition should be a requirement. No pay == no non-compete.

If they're not paying, they shouldn't be able to keep you out of the market, period. It's not a fair trade otherwise and just having a job in the first place is not even remotely conscionable as 'consideration' for a clause that prevents you from working.
Have you tried thinking for more than 5 minutes? Surely this is not an insurmountable problem. Here, literally the first two things that pop into my head wrt. to this issue:

1. Heat storage: incorporate some sort of long-term energy store that allows us to sink extra energy from the warm season and reclaim it during the cold. We already have this technology, nothing new.

2. Use the warmer areas to power the colder. This thing will create its own power grid, right? So we don't have to rely solely on the one panel to produce its own energy for heating, it can take advantage of the entire network of panels. As long as the entire network of panels is generating a surplus (which back of the envelope calculations say it could), then you're fine.

I'm sure if I spent any real amount of time thinking about it I could find other solutions.

So maybe we can be a little more creative than, "the new system cannot function in exactly the same way as the old system, therefore it is impossible." You are the one being intellectually lazy.
I suspect that all the languages that are "winning" right now will have "lost" 10-20 years from now too.

What's the longest lived language out there right now that's actually still in heavy use? I'd say C. But C has clearly fallen from its position of complete dominance when every new project was written in C (because it was much easier than writing assembly).

C++ had its day as well and lives on in many places, but again, it's no longer the go to language for projects where C isn't the right choice.

How about Java? It was hot stuff in the 90s and it's still huge today, but it clearly didn't "win".

PHP? We'll be living with legacy PHP code bases for at least 10-20 years but does anyone honestly think this will be the language that the startups of 2025 use?

Programming is both incredibly faddish and incredibly fast paced. Today's new hotness is tomorrow's "dead" language.

Give it 5-10 years and I expect to read "Why Python Didn't Win". I expect we'll see a "Why Ruby Didn't Win" in 10-15 years too.
Haha. Yea, I've seen those patterns too. Since 1995. Its like nobody reads the books we all talk about.
How the NSA plans to prevent another Snowden
I don't know if you're aware of this, but your comment seems laden with anti-Chinese sentiment ("Chinese-ridden") that doesn't seem justifiable by facts nor by modern standards of treating other people.

First, the demographics of California are not what you state. People of Asian descent comprise ~15% of the population of California, not 40%.

Second, is there evidence that the rationale for the selection of the inexperienced company from China was influenced by anything except for nominal cost? Specifically, is there evidence that race was a factor in the company's selection? Perhaps I'm wrong but it seems highly unlikely prima facie.

Third, if we accept as fact that third-world nations don't grasp the essentials for running sustainable society (which I don't in general, but will for this comment), then what is the relevance of that to Chinese Americans? I would argue that there is none.

Fourth, Chinese taxpayers lost money just as much as non-Chinese taxpayers, proportional to their tax payments.

Fifth, phrases like "Chinese-ridden" have no utility except as derogatory terms. Deriding an entire race of people makes absolutely no sense, as your race does not determine your person nor even your culture. Basically, it comes off as racist.