Ask HN: How to increase revenue on my site (Tekkenpedia)? - <AUTHOR>

I've been running a wiki about the videogame "Tekken" for around seven years.
A few details about it:
- Been running for 7 years
- 1000's of pages of content
- Regular core of people contributing to it.
- 600,000 page views per month
- 79,000 uniques per month
- 119,000 visitors per month
At the moment I'm not running any ads but with Adsense I make an alright amount (can't say exactly how much without violating the TOS). Enough to pay for the server hosting.
What I want to know: is Adsense the best option? Should I be looking at other networks or advertising methods?
I want to balance how much money I make with how much I annoy people using the site :)
Full stats report here:
http://eng.tekkenpedia.com/combined_document.pdf <comment><USER2> Cut out the middle man and get your own advertising instead. Adsense has one of the best payout rates in the industry, but you have to remember that Google is merely the middle man for every $1 they're paying out they would have to at least be making $5 - $10 more so they're always ahead.

With stats like that there isn't a reason you can't go out and solicit advertising yourself from gaming companies, stores and publishers and show ads yourself without using a third party advertising network. That is probably one of the most obvious pieces of advice I can give you at this point, but if I think of anything else I'll let you know.

<comment><USER3> >you have to remember that Google is merely the middle man for every $1 they're paying out they would have to at least be making $5 - $10 more so they're always ahead.

Google pays 68% to the publisher. [http://adsense.blogspot.com/2010/05/adsense-revenue- share.ht...](http://adsense.blogspot.com/2010/05/adsense-revenue-share.html)

<comment><USER4> Google AdExchange is 80/20 in your favor

</comment></comment></comment><comment><USER5> I don't know if this will apply for your case, but I have a big website for an specific fandom (similar to videogame, it is a little nerdie), which lead to a bigger Twitter account (almost 200.000 followers).

Try to monetize it with content which will get attention from your visitor. Run teespring campaigns, contact shops who sells merchandising, and that kind of stuff.

You can also create a blog and ask shops and manufacturer for products to write reviews. You will receive them, and after the review, you can sell them.

<comment><AUTHOR> Thanks for the tspring link. I'm a bit worried about selling anything with the Tekken brand on it but I suppose I could see if people wanted to buy stuff related to the Tekkenpedia brand.

The blog idea is also interesting, I could branch out somewhat from the core game and maybe into other fighting games.

</comment></comment><comment><USER6> One thing you might try is taking notes on what Adsense shows (and what shows on competitor sites). You might find a product that is a good fit that way - you might also look through the search keywords in google analytics and see if any are purchase based. You might be able to add Amazon affiliate links as well.

</comment><comment><USER7> It isn't just about the payout, it is precision too. You hit a very narrow demographic that spends money.

</comment><comment><USER8> Sell over priced merchandise.

<comment><USER9> Give it a try. A long time ago I ran a shop which sold merchandise related to only a single anime/manga series, much smaller niche than Tekken is. I recall it was still making around $1000 / month in profit (nice but ultimately other things took over). If you can engage your community such that your shop becomes the go-to place for hard-to-get Tekken products, it could be lucrative. You already have the traffic of people interested in this, so most of the work is already done.

It would be a service to your userbase and wouldn't need to be annoying. Having a "tekken shop" link in the sidebar, links from your relevant content pages to the relevant shop pages (perhaps even have those content pages BE the shop pages) and periodical more visible banner campaigns (christmas sale, limited sale of some rare item etc) to raise awareness that the shop exists should be enough.

You can start small too. You can just honestly write "we are thinking of opening a shop for Tekken items. Are these some specific items you are looking for?" and have a textbox where people can write their request. If it seems like there is demand and some products emerge that get requested, you can then go ahead and have a simple paypal cart to buy the item. You could do this in the next 30 minutes.

Don't be shy to have a high margin for products which are difficult to get elsewhere and you might just find that you successfully pulled off turning your passion into a business.

<comment><AUTHOR> This is awesome feedback. Exactly what I was looking for.

I like the idea of sourcing say signed items and reselling this. Collectors items.

<comment><USER8> I wod just go right out and buy something off of eBay. Then sell it in the wiki. No ecommerce store or anything, just a page with a PayPal button in it. Do explain to people why you are doing it. And ask if they would buy cheap stuff from you such as stickers. Just do t waste anytime with getting things right. Everyone knows a King action figure always sells. (:

</comment></comment></comment></comment><comment><USER10> Shoot me an email, I own a few gaming wikis I would love to chat sometime.</comment>


OpenPhotoVR: OpenSource Flash implementation of Photosynth - <AUTHOR> http://openphotovr.jottit.com/

<comment><USER2> It doesn't really analyze multiple photographs taken of the same area, but it is good enough photo browser that resembles Photosynth. See the created images of Pioneer Square, Portland.

<http://openphotovr.org/#JVwMyUCt>

Note: the site is little slow and sometimes it doesn't load.

</comment><comment><USER3> Wow, thanks again nickb :-)</comment>


Raspberry Pi as an Ad Blocking Access Point - <AUTHOR> http://learn.adafruit.com/raspberry-pi-as-an-ad-blocking-access-point/overview <comment><USER2> I hope that readers understand you don't need a RPi or dnsmasq to accomplish ad blocking. That said, this in my opinion an excellent use of a small form factor computer: as a gateway.

As a side note, what would happen if we put our own private address space "web apps" on our gateway? Voila, the added "web app" functionality that our devices expect, without the need to use third party servers on the public internet that collect personal info.

In any event, if you do not have a Pi, you could just as well use any old i386 computer and any old DNS server software.

I use a gateway like this not to block ads but to detect and, if necessary, stop mobile apps that phone home (and send out payloads of private data). You would be amazed at what some of these apps want to send over the internet for no good reason.

And, rather than use a HOSTS file as a blacklist, I use it as a whitelist by populating it with all the sites I might visit.

For example, using a localhost recursive DNS server, I pre-fetch all IP addresses for all the sites appearing on HN and put them in /etc/hosts. This makes reading articles posted on HN much, much faster than if using an ISP's DNS cache or some public, open resolvers like OpenDNS or Google.

Again, my compliments to the author for a great use of a small form factor general purpose computer.

</comment><comment><USER3> Nicely written, very clear instructions.

I'm still not sure what I think of adblocking... in some ways it makes sense that I can display what I want on my computer, but on the other hand, advertising on web pages is a legitimate and reasonably sane business idea.

I don't adblock, but I do have flash on 'click to play', which does stop the most egregious and annoying ads.

My guess is, in time, that ad-blocking will simply mean more javascript and html videos (possibly using that clever canvas trick that was demo'd the other day) which are impossible to stop.

</comment><comment><USER4> Instead of blocking the DNS, you are much better off running an intelligent HTTP proxy that can just filter out the bad stuff. Try installing 'privoxy' \- it's available packaged for most Linux distributions. You can then use dnsmasq to push it as the recommended proxy for clients, or set up a few firewall rules to turn it into a transparent proxy.

<comment><USER5> Of course that won't work for HTTPS sites, which are becoming more prevalent

(PSA: install EFF's HTTPS Everywhere: [https://www.eff.org/https- everywhere](https://www.eff.org/https-everywhere))

<comment><USER6> Some proxies (e.g. squid) include transparent HTTPS proxying; you just need to generate a certificate and add it to your browser.

<comment><USER5> Does it work with Chrome's certificate pinning?

</comment></comment></comment></comment><comment><USER7> It really reminds me of how you block ads on a router that allow SSH access (like any router running Tomato, DD-WRT, OpenWRT...).

There are several guides online, like [http://www.linksysinfo.org/index.php?threads/all-u-need- ad-b...](http://www.linksysinfo.org/index.php?threads/all-u-need-ad- blocking.33191)

Anyway, I have mixed feelings on blocking ads at the router level (or using the RasbPi to block them). Those methods don't allow control, so if you need to disable adblocking for any reason, it's not something you can do just pressing a button.

Also, since it doesn't work on a per-site basis like Adblock Plus, you can't disable it on sites that you want to support and use ads in a non-intrusive way.

<comment><AUTHOR> The guide does include ways to whitelist sites [1] you'd like to support (and mentions it's a good idea!) and is on a per-site basis. It pulls in an ad list from a popular site [2].

[1] [http://learn.adafruit.com/raspberry-pi-as-an-ad-blocking- acc...](http://learn.adafruit.com/raspberry-pi-as-an-ad-blocking-access- point/install-software) [2] [http://pgl.yoyo.org/adservers](http://pgl.yoyo.org/adservers)

<comment><USER8> I think he was talking about a way to quickly toggle the ad blocker on/off.

<comment><AUTHOR> Yea, I didn't write that part out, but it would be fairly easy to write a bash script to turn it on and off (and even a simple web site with a on/off button, as you are running apache in one of the solutions). You could just move the dnsmasq.adlist.conf file out of the dnsmasq.d directory, and then restart dnsmasq.d, and vice versa.

<comment><USER9> Even better, with a Raspberry Pi, you could build a physical switch to flip to turn ads on/off.

</comment></comment></comment></comment></comment><comment><USER10> In addition to blocking ads, I suggest anyone implementing this also blocks all websites containing ads.

Why? When you "say goodbye to ads" you're also saying goodbye to the source of income that pays the people who made the website.

No money, means no employees to create the website, means no more website.

Not everything can be open source / free. Nor should it be. People deserve to be able to make a living doing the work they do.

<comment> mike-cardwell They're not Ads. They're malware distribution and tracking networks. It is unsafe to browse the web without blocking Ads. I would recommend everyone blocks them, for their own security and privacy.

When websites start displaying Ads in a manner that doesn't allow cross site tracking, and in a way that doesn't create massive centralised points of failure for the web, I might start letting them onto my network.

<comment><USER11> Disallowing 3rd party cookies will end cross-site tracking. (In practice, opting out[1] will pretty much cover you too, but I understand why you might not trust it.)

[1] [http://www.networkadvertising.org/choices/](http://www.networkadvertising.org/choices/)

<comment> mike-cardwell Disallowing 3rd party cookies wont end cross-site tracking. They want to do it so they will find ways to do it. Even if they ignore all of the obvious and underhand methods like exploiting E-Tags and Cache headers, they can always just track clients across sites based on their IP address. Yes, that is not as accurate as using cookies, but it is accurate enough to make more money than they would make by not doing it.

</comment></comment></comment></comment><comment><USER12> Very interesting. Only flicked through, but please don't run Apache on a Pi; waste of CPU and memory, run nginx or pixelserv (as suggested).

<comment><USER13> bigoted opinion.

Apache runs fine on the Pi. Memory considerations aren't a concern when you have 512MB of RAM, and CPU difference is neglibible for these small workloads.

<comment><USER12> Sorry, I disagree. Nginx is a much better web server than Apache.

</comment></comment></comment><comment><USER14> Reminds me of the first Project I did with my Pi (last year) except I was using Squid and two Ethernet Ports (Apple's USB to Ethernet Adapter is basically plug and play with Linux). I eventually did a Wifi version, very similar to this article. I then developed a basic Web based UI that allowed you to turn it On and Off by clicking a button. The next step was to use the GPIO Pins to hook up a physical switch that you could press to turn it on/off, but never went that far. For a while there I thought about packaging it as a Product and trying a campaign on Kickstarter, but I didn't like the idea of just repackaging someone else's Hardware and Code and selling it as my own. Eventually someone else did their own version (AdTrap) and was mildly successful. These days I'm still working on Pi projects as a side hobby, got 2 Projects I'm working on right now. Ironically, one of them supports the Advertising Industry (but not in the way one might think), and the other has to do with Content Delivery. The only real challenge I have (and it's a big one) is taking the next step and building something for mass production. Since the Pi is pre-made, I view it as a great platform to build a prototype, but not necessarily a good platform for mass distribution of a product (from a business perspective, production cost too high). For anyone else into it, check out the new GPS chip's they're selling. Awesome possibilities!

Regarding Ad's and Blocking Ad's, I have no remorse building something that gives the consumer a choice to blocks Ad's. While I do agree that Ad's can be a viable and acceptable business model, it is my personal opinion that the Advertising Industry has been abusing consumers for decades. And I find this detrimental to the Industry as a whole. I think it's about time that the consumers had a choice. I find the average (aka normal) user experience of your typical Ad (in any format) to be horrible; The Ad is basically forced on you. I also find that the Advertising Industry has little regard for the consumer's Privacy, which I do not find acceptable (as a consumer). I do think that there are innovative ways to Advertise and create a positive experience, but I don't think the industry (as a whole) has realized/embraced them yet. It seems to me that the Advertising Industry is stuck on a model developed in the 60's, and has continued to push this old model even while technology evolves. I think it's time for the Advertising Industry to evolve. Hopefully I can test/validate this with one of my next Pi based Projects.

</comment><comment><USER15> For those of us who don't have a Raspberry Pi there's AdSuck, an ad blocking DNS server from Conformal.

[https://opensource.conformal.com/wiki/adsuck](https://opensource.conformal.com/wiki/adsuck)</comment>


Former MUNI mechanic proposes sailwing engine design to replace windmills - <AUTHOR> http://www.sfweekly.com/2013-06-19/news/mike-cheney-muni-sailwing-san-francisco-examiner/

<comment><AUTHOR> What I'd like to see is a review of his plans, i.e., is this truly feasible?

And also, I'd like to see the critique balanced against that of windmills: Is the noise comparable? (Sounds like this design would have a greater noise factor because of the hydraulics.) Is the threat to wildlife comparable? (Sounds on the face of it like birds would see the moving sails more easily than the thinner sails of Altamont Pass-style windmill sails, but I'm no expert.) For the hydraulics, what's the cost/distance effectiveness ratio?</comment>


Strong Password Hashing for ASP.NET - <AUTHOR> http://zetetic.net/blog/2012/3/29/strong-password-hashing-for-aspnet.html

<comment><AUTHOR> With PBKDF2 (Rfc2898DeriveBytes) sitting in the base class library for years now, I'm not sure why Microsoft have neglected to have it implement the normal hash algorithm interfaces... it's just a few lines of code, and much, _much_ better than the SSHA1 / SSHA256 that remain the default for SQL user databases.</comment>


PanoJS3 - An Interactive JS Widget For Panning And Zooming A Panoramic Image - <AUTHOR> http://www.dimin.net/software/panojs/ <comment><USER2> Dragging the box in the tiny thumbnail is a drag (it's a tiny input area for panning around a huge surface). Panning the main image is broken since when the cursor leaves the element, panning stops. Why am I looking at little spinning animations when I've been on the page for five minutes and could have had those loaded in the background? The above combination yields a "meh" from me.

</comment><comment><USER3> I've been using this viewer:

<https://github.com/can3p/iviewer></comment>


Samsung DeX provides an easy way to turn the S10+ from a phone to a desktop - <AUTHOR> https://www.androidcentral.com/samsungs-dex-best-thing-nobody-cares-about <comment><USER3> Sadly, Dex is hardly ready for any sort of full time replacement. The fact that it eats key presses (samsung reserves some common key press combos, for odd and atypical behaviors, for instance, if you press shift and space within two seconds of each other, it eats the keypress, and tries to activate the change language option)

For the hardware its running on, I found it surprisingly sluggish.

Over all, I wish they'd just call it beta software, and not ruin first impressions with this really buggy implementation, of a brilliant idea.

<comment><USER4> > if you press shift and space within two seconds of each other, it eats the > keypress, and tries to activate the change language option

That annoys me too, but Windows also has a similar problem - if you accidentally press Start key & Space at the same time, it switches you to the next keyboard language. I wish I could turn that shortcut off on both operating systems.

</comment></comment><comment><USER4> I got a DeX Station for my S8, as the official ones are really cheap on eBay now. Plugged into my Dell monitor & bluetooth keyboard and mouse, it's a surprisingly good desktop experience. It feels like the direction Apple might be heading with Marzipan too - imagine if there was an iPhone dock that let you run iPhone apps just like desktop apps, like an alternative to a MacMini.

The DeX Station has a built in USB port, and the big surprise for me was that you can plug in an external USB hard drive (and with the right software you can access Windows NTFS & Mac HFS drives), and it even works with my Focusrite 2i2 audio interface. Once I plug in the Focusrite, suddenly my phone can play music over my JBL studio monitors. (I haven't had a chance to test if I can record phantom powered microphones at 24-bit 96kHz with it, but I've seen blog posts suggesting that should be possible too.)

</comment><comment> m-p-3 I just need a command-line environment for some of my stuff when I'm remote, and Termux so far does the job wonderfully for a small amount of processing power.

I can even pass URLs to the share intent and run commands on it (ex: youtube- dl, etc)

<comment><USER4> I'm more used to a workflow like Panic Coda (integrated text editor with built-in SFTP). For that, I found Quoda [1], even the name suggests it's trying to be a Coda clone for Android. It's a bit rough & needs work - <USER2> near as good as Coda on the Mac - but it got the job done when my main machine was broken & I had to use my DeX for a while.

Termux filled the terminal gap for me as well.

[1] [http://getquoda.com/](http://getquoda.com/)

</comment></comment><comment><USER5> Great, now we just need a laptop-like dock.

</comment><comment><USER6> The Linux on DeX looks pretty legit.</comment>


Ask HN: Can you recommend a personal email provider with regex aliases? - <AUTHOR> Hi HN, my email provider pulled a fast one on me over the weekend - overhauling their UI and dropping their regex alias functionality without warning. Not what you want from a paid service.
I very successfully operate a <site>.<date>.<nonce>@<mydomain> schema for personal email, using regex aliases to manage "users", and blacklists to eliminate spam. The largest draw of this schema is detecting when companies are breached / leak my data (4 times in 6 years), and when some company misuses information I gave them for something else (countless times).
I also use it to manage alerts and priorities for a handful of custom systems to special mailboxes.
Not every email provider can support such a schema, and until today I was very happy with mine - charging only for a ceiling on daily sends and total mailbox size with unlimited mailboxes.
I don't want to go back to managing my own email (though if I have to I will) - do you guys have any recommendations? <comment><USER2> FastMail supports regex matching any header, including To/CC/BCC: [https://www.fastmail.com/help/receive/regexprules.html](https://www.fastmail.com/help/receive/regexprules.html)

Multiple rules can be ANDed or ORed as well, if you don't want to make a single regex that's more complex.

They use - and expose - Sieve: [https://www.fastmail.com/help/technical/sieve- howto.html](https://www.fastmail.com/help/technical/sieve-howto.html)

</comment><comment><USER3> Doesn't a simple catch all work for you?

<comment><AUTHOR> For a basic case it would; however I also drop certain combinations by default (/.*\\.blackhole@/), prioritise certain mail (synology boxes, and services/people I am waiting on are aliased to a specific mailbox which vibrates my phone), aggregate other mail (todo's go to their own mailbox for example), and offer a disposable mail mailbox for my partner.

I was perhaps a tad simplistic with my initial description; I didn't want to bog it down with the detail.

In addition the implementation of catch alls on most services tend to circumvent blacklists (which I would like to do on receiver email address, not sender) and to catch mail destined for deliberately independent mailboxes.

</comment></comment><comment><USER4> uberspace.de

They use qmail and I did something rather similar for myself.</comment>


Prismatic's "Graph" at Strange Loop - <AUTHOR> http://blog.getprismatic.com/blog/2012/10/1/prismatics-graph-at-strange-loop.html <comment><USER2> I love reading prismatic's blog. You have some really smart people there. However, it seems like you're trying to solve everything from a purist view and I think your product is suffering as a result. I have made the same suggestion consistently that would make me use it more without any reply. Basically, I've stopped using the product as the UX does not match the reason I would want to use the product.

<comment><AUTHOR> I'm sorry about that. If you're still interested in giving us UX feedback send us an email email@example.com. I'll personally respond to it. Please understand that we're still a small team and we get a lot of emails on a daily basis. :-)

<comment><USER3> I agree with the author, the UX is definitely under-developed and I've also given many feedback msgs.

We only say this because we care :)

</comment></comment></comment><comment><USER4> This sounds very useful. I'm having trouble understanding the nature of the system, though, because I don't really understand lisp / clojure. Is this a pattern that could be applied in any language with first class functions, or does it require a lisp to be practical?

<comment><USER5> Sure! This particular way of expressing declarative structure may be specific to Clojure, but the basic ideas should be useful in any (especially dynamic) language with first-class functions.

The first idea is to take a complex system and express the set of components and their relationships declaratively, rather than procedurally. This is an old idea, and makes it possible to reason about the system, mock out components for testing, map over the components for monitoring, and more.

The second idea is simplicity. By making this declarative language as simple as possible, it becomes trivially easy to do all the things I just mentioned using the existing tools in the language, without needing to write complex library functions to support each use case.

For another example of a declarative system for composition you could look at 'react' in JS, which can be used in similar ways to Graph (and also supports things like async composition): <https://github.com/jeffbski/react>

<comment><USER4> Thanks! That makes a lot of sense, and react looks like a really interesting project. I'll have to go back and reread the article with an eye for applying its ideas in Javascript / Coffeescript.

</comment></comment></comment><comment><USER6> Pretty cool project, like a functional reinterpretation of dependency injection frameworks. The basic idea behind dependency injection is to make all dependencies for each unit explicit and externally supplied.

DI frameworks then build upon the pattern offering a declarative DSL to declare dependencies and wiring. They also offer a selection of alternatives to build dependent objects (e.g. build a fresh one when needed or supply a global instance for every dependee) and a smidgen of generic functionality via impersonation (e.g. monitoring, logging, timing, transaction acquisition/release).

Interesting that untyped functional programming and macros allow for a lighter expression of the same basic idea.

Also interesting that maps of functions are a fundamental part of the solution. There are definitions of object-orientation that amount to basically records-of-lambdas. I've long thought that there is a lot to gain by using this basic abstraction as it naturally provides seams for testing/observability/auditing/etc.

</comment><comment><USER7> Is it just me or is the prismatic blog text being cut off on the side? [https://twitter.com/blaines/status/256545302926995456/photo/...](https://twitter.com/blaines/status/256545302926995456/photo/1/large)

<comment><USER7> Appears this may be a retina mbp thing...

<comment><USER8> happens to me on an iPad as well

</comment></comment></comment><comment> a-priori Very interesting, needs more examples though.

It seems like this fits a similar purpose to Nathan Marz' Storm framework. Could you do a bit of a compare/contrast thing between Graph and Storm?

<comment><USER5> Thanks! There are some more complex examples in the slides, I just didn't want to make the blog post any longer.

The main similarity between this and Nathan Marz's Storm framework is that they both rely on a declarative expression of the structure of the computation graph.

However, beyond that there are many key differences. Storm is a graph computation framework, which compiles your specification into a distributed real-time computation pipeline. In contrast, Graph is just a _library_ for expressing composition structure, but says nothing about execution strategy.

In principle (with a lot more code and some more annotations), one could compile Graphs into distributed real-time topologies like Storm. For now we've been using Graph in-process for real-time processing. But because Graph is so simple and close to the language, it's very easy to apply to new situations and build new abstractions on top of. For example, we also find Graph useful for expressing the composition structure of our production services, which are built up from many components.

<comment><USER9> But, from what I understand, if I structure my software using Graph, it should be much easier to run it using Storm, even without automated tooling. That way Graph becomes a stepping stone: structure your software, and _if_ you need Storm's parallelism/scalibility, define a topology using the same functions.

</comment></comment></comment><comment><USER10> This is great, but I wish they'd take it one stage further. At the moment, the first example they give (monolithic let) is pretty idiomatic and readable. The transformation from one to the other is pretty automatable. So for most cases, why not just put a macro on top? e.g. defgraph-asfn

Storm requires some manual intervention because you need direct control over how things are distributed.

</comment><comment><USER11> Nice. Assuming that the computation of each node is memoized, can we 'dirty' a single node, so that during the next computation only the needed parts of the graph are recomputed? This would make multiple computation of models where only a few parameters are changing much more efficient.

Also, has this at all been inspired by SecDB's powerful graph oriented features?

<comment><USER5> We haven't had the need for that application yet, but it's certainly possible -- that's why declarative specifications are great :)

I haven't heard of SecDB, but I'll definitely check it out -- thanks!

<comment><USER12> This is definitely a use case I am interested in. I have been playing around with computer algebra in Clojure for awhile where it is critical to keep track of these dependencies (I have a hacky implementation which relies on metadata so that the resulting data structure is out of site). But of course, when you actually want to evaluate something, this is when you need to get sophisticated. There can be multiple paths in the graph to arrive at the same node and you have to decide. With memoization at nodes being an important consideration. Anyway, I would be very happy to see an open source version of this!

P.S. As I understand it all the graphs are dags. In my line of work (which involves doing stuff at the interface of probability and statistics) there are quite a few recursive functions that are difficult to unroll explicitly, or are otherwise undesirable to unroll for the purposes of readability. Can we expect to see circular dependencies at some point. Well, I know, the halting problem and all, but still...

</comment></comment></comment><comment><USER13> This feels like lazy evaluation bolted on to Clojure (cool!). There's further benefit since you get some dataflow abstraction—which then reminds me of the Par monad.

<http://community.haskell.org/~simonmar/par-tutorial.pdf>

<comment><USER14> There's no need to "bolt on" lazy evaluation since (future) and (delay) are parts of the core language (not to mention lazy seqs)

<comment><USER10> Well, future, delay and lazy sequences are bolt ons to an eagerly evaluated language. I'm not convinced the laziness is Haskell is worth it, tbh, but its true that you really wouldn't need this project.

<comment><USER13> Usually these kinds of demos are the same as the ones touting the virtues of Haskell's laziness. The visualization is really nice, though, along with the possible paralleization. I think the Par monad is a more interesting comparison, honestly.

[http://hackage.haskell.org/packages/archive/monad- par/0.3/do...](http://hackage.haskell.org/packages/archive/monad- par/0.3/doc/html/Control-Monad-Par.html)

</comment></comment></comment></comment><comment><USER15> Happy to see you're opensourcing. Are you planning to do the same with Flop and Optimize?

<comment><USER5> Flop is definitely on the list (with about 10 other libraries), but I'm not sure about our optimization code. We plan to start a discussion of what we should prioritize soon, so stay tuned.

</comment></comment><comment><USER16> Just a heads up, it looks like something is up with your CSS:

<http://cl.ly/image/241X1C2D3O35>

I'm on 10.8 with the latest version of safari.

In other news, this looks pretty cool.

<comment><AUTHOR> Are you using a Retina Macbook?

<comment><USER17> I have the same issue and i'm using a Retina MBP.

<comment><AUTHOR> Thanks guys. We will look into it.

</comment></comment></comment></comment><comment><USER18> If I understand the nature of this system, it's essentially a higher-order function composition tool. Correct?

Nit, defnk? what about def-kw-func or something? not wholly readable as defnk.

<comment><USER5> Yep, that's correct.

Point taken about the names, thanks for the feedback. Since Clojure already uses defn and fn, defnk and fnk seemed natural. But maybe defn-keyword and fn- keyword would be better.

<comment><USER18> I really like this idea. Do you have a Common Lisp port of this, out of curiosity? If not I might have to see what I can come up with. :-)

I like to have fully expanded names, ala Common Lisp. My editor will autocomplete those on demand after I use a name once, so it's not a hindrance to reading or writing.

My goal for identifiers is that I can read without consulting my internal lookup table.

<comment><USER5> Thanks! Nope, no common lisp port -- and we haven't released the Clojure yet, but plan to soon. It's only 150 lines of code or so should be easy to port or rewrite from scratch.

</comment></comment></comment></comment><comment><USER19> Graph reminds me of working with Spring (from what I remember of that). The concepts sound very similar to Spring's auto-wiring.</comment>


Can tiny plankton help reverse climate change? - <AUTHOR> http://aeon.co/magazine/technology/can-tiny-plankton-help-reverse-climate-change/

<comment><USER2> One of the main "protests" from scientists (like myself) is _not_ that this doesn't sequester carbon. But by sopping up macronutrients (nitrogen in particular) to form large diatoms, you greatly disadvantage smaller, floating plankton that stay afloat and actually feed the marine food web.

Note: I'm not against the actual small-scale experiments. We may someday have to choose between sequestration and whales. Just pointing out that the objections to large-scale use aren't as silly and reactionary as the article makes them out to be.

<comment><USER3> I am not a scientist, but this objection seems rather short-sighted. The threat posed by global warming is to the ecosystem as a whole. If the smaller- scale (but still large) systems are negatively affected, but the system as a whole is saved, then this would be a worthwhile effort.

<comment><USER4> I am a scientist (a botanist) and I don't think the objection is short sighted. You are fundamentally changing the base of the marine food web. This is not a system that is well understood, and one that is difficult to model. This type of intervention might be successful, but you could also kill off large amounts of marine life, making a bad situation significantly worse. That doesn't mean geoengineering shouldn't be explored, but it's potentially risky. A wrong move could lead to mass starvation of not only marine life, but the numerous human populations that depend on that marine life.

</comment></comment></comment><comment><USER5> The Scientific American article about this experiment has a much better analysis of the pros and cons of seeding the ocean with iron - [http://www.scientificamerican.com/article/fertilizing- ocean-...](http://www.scientificamerican.com/article/fertilizing-ocean-with- iron-sequesters-co2/)

 _" But such fallen carbon only resides in the deep for a few centuries at best. Eventually, it makes its way back to the surface as the ocean's bottom water circulates and rises anew near the equator (although carbon buried in sediment might stay buried longer)."_

<comment><USER6> A few centuries kicks the problem down the road a long way. If we successfully sequester enough carbon to prevent any horrific consequences of energy generation until, say, 2300, well, by 2300 people may well have plenty of additional options to deal with the carbon.

Or at the least they'll probably be able to just once again sequester it through the same techniques.

Or else global warming will be the least of humanity's problems in 2300.

</comment></comment><comment><USER7> The problem with solutions like this is that the Ocean itself is already the most efficient machine for cleaning the Earth's atmosphere - well over half of the oxygen that we breathe comes from the Ocean, and well over half of the carbon that we exhale is cleaned by it. Focusing on its' health will greatly benefit the health of the environment that we rely on directly.

<comment><USER2> When "ocean health" is talked about, restoring ocean "health" (restricting fishing, land use, etc.) is not expected to have measurable effects on carbon sequestration in particular. And while the ocean ecosystems have evolved to be "robust", that is different than "efficient" \- evolution can come up with some fairly inefficient solutions.

</comment></comment><comment><USER8> Our arrogance in assuming we can some how control the climate of the entire planet is the most worrying thing about this to me. We can barely predict the weather beyond a few days let alone make measured predictable changes to the climate.

If a solution like this were to get out of control or go too far we could find ourselves in a far worse place than we are now.

<comment><USER9> Which is more arrogant:

1\. Forming hypotheses on admittedly half-assed reasoning, performing small verification experiments, gradually scaling them up in order to see if predictions match observations, and iterating upon failure

2\. Declaring that nothing we ever think of will ever work well enough to be worth trying in the first place

[http://joyreactor.com/post/578357](http://joyreactor.com/post/578357)

You see #2 all the time in the media, especially in science fiction. To me it comes across as a desperate attempt by scientifically ignorant authors to extend the purpose of their story beyond that of mere entertainment. It's a noble goal to strive for, but actual safety analysis is boring, difficult, and far beyond the scope of your typical techno-thriller, so it inevitably gets half-assed into the predictable form of a bunch of chase/destruction scenes followed by the inescapable conclusion that goal X is simply too dangerous to be worth investigating -- in fact, it's so dangerous that the scientists were _arrogant_ for investigating it in the first place. _Retch_. I actually wouldn't be particularly bothered by this plot device (I like dinosaur chases and zombie hunts, too) if people didn't go and project the same vapid thought process onto real-life scientists solving real-life problems. But they do. Parent post is a case-in-point.

Either do the bookwork/coursework/reviews/calculations necessary to leave constructive criticism or leave the floor to people who have. Don't stand up and claim that your ignorance is better than someone else's knowledge. _That 's_ arrogance.

<comment><USER8> Really, so if he proves that it can remove CO2 from the atmosphere, which I'm confident he is right about, has he proofed it is safe to do so on the scale required, simply no.

Our models of real world are woefully general, I doubt we even have the computing power available to crunch all the variables.

It seemed a good idea to bring cane toads to Australia to combat the damage done be cane beetles, foxes were brought to combat rabbits. Hint, none of these attempts at environment management went well, even though they are relatively simple problems; foxes eat rabbits right?

<comment><USER10> Can we stop the stupid cane toad meme. The scientists at the item told the cane farmers not to bring in the cane toads and they ignored the scientists and brought them in anyway.

</comment></comment></comment></comment><comment><USER11> Interesting article, but I'd like to see the facts laid out behind this excerpt:

"The variety of shapes among plankton species shames plants on land, showing more range in size than the difference between moss and redwood trees. There are more plankton cells in the sea than our current count of stars in the entire universe. "

</comment><comment><USER12> A man named Smetacek is working on cleaning up oceans, neat!

The original Czech spelling of the surname with all the diacritics is Smetáček.

The word means "dust brush"; a diminutive word which denotes the little cousin of the smeták.

[https://www.google.com/search?q=smet%C3%A1%C4%8Dek&tbm=isch](https://www.google.com/search?q=smet%C3%A1%C4%8Dek&tbm=isch)

:)

</comment><comment><USER13> Why are we seeking solutions like this? Because by investing in them, we can also make money by selling the solution / services / patents to governments.

Why don't we instead focus on reducing society's consumption? Because we would not gain any profit from such venture.

If this is true, we are already extinct.</comment>


Show HN: gRPC-Dump, a gRPC/gRPC-Web Debugging Proxy - <AUTHOR> https://github.com/bradleyjkemp/grpc-tools <comment><AUTHOR> I find debugging gRPC requests can be a pain because debugging proxies like Fiddler/Charles don't natively understand gRPC. So I built _grpc-dump_ to try and make this easier by doing interception at the gRPC level rather than the HTTP level.

Without requiring any client/server changes, _grpc-dump_ transparently intercepts traffic on your machine and logs a JSON stream of all gRPC(-Web) requests that are made. This stream/dump is already useful for debugging but I've also started adding tools like _grpc-fixture_ which uses this dump and responds to future client requests with the saved server responses from the dump.</comment>


C to Go: Could Go replace C? - <AUTHOR> http://www-cs-students.stanford.edu/~blynn/c2go/ <comment> old-gregg To replace C, one must create a language which, first and foremost, can target shared libraries, because that's how most of systems software operates on virtually all current day's operating systems.

This is by far the #1 requirement: extensions to all VMs and scripting languages are shared libraries. Plugins for various servers are shared libraries, heck pretty much everything which is not a web app is a shared library, either on windows or linux.

In my life as a C++ developer (about 7 years) I have never, even once, worked on an executable. All my code, at all companies where I worked, always ran inside of either a DLL or a so-file loaded by some hosting process.

In fact, I believe that so-files must have been the default compilation target for both Go and D. So millions of Ruby/Perl/Python/Java/<anything goes> programmers could have used those languages for performance-critical or OS- dependent code in their programs, after all that's what "systems languages" are for.

<comment><USER2> I know that shared libs are prominent and a better support for them would probably help Go's popularity. (Though the idea behind shared libs is somewhat flawed.)

But it rocks to deploy a Go app by just sending the binary to a dozen of servers and never have to worry about any dependencies on shared libraries.

<comment><USER3> Savvy Win32 devs used static linking whenever they could to minimize deployment hassles way back when. :)

</comment></comment></comment><comment><USER4> I remember a time when people asked, "What will replace the floppy drive?" Everyone expected the replacement to look and feel like a floppy drive, but with more speed and capacity. In the end, the "floppy killer" never materialized. Several unrelated technologies ended up taking over floppy's uses one-by-one. CD-ROM's took over software distribution, USB thumb drives took over file transfer between computers, and the network took over everything else.

The same thing will probably happen to C. Modern languages like Python or have arguably "replaced C" in several use-cases already. Go will probably claim a few more. On the other hand, Go is completely unsuitable for applications that cannot tolerate garbage collection, such as embedded firmware. Some other language will have to come along and claim _that_ niche from C as well.

<comment><USER5> I'm not so sure there are applications which simply cannot tolerate garbage collection. Unless, you have no reasonable way of preventing allocations.

Console games, for instance, are often largely garbage collected, despite being hugely performance critical applications. The way this is generally achieved is by allocating 100% of the console's memory upfront as object pools. The game then utilizes domain specific collection mechanisms on those pools.

Shawn Hargreaves has a good article on dealing with C#'s garbage collection in XNA games: [http://blogs.msdn.com/b/shawnhar/archive/2007/07/02/twin- pat...](http://blogs.msdn.com/b/shawnhar/archive/2007/07/02/twin-paths-to- garbage-collector-nirvana.aspx)

The problem in .NET land is that some base class library methods allocate internally, so you need to completely avoid them if you use "Path 1" (avoid collections). You wind up having to do funky things like re-implementing core methods and pre-allocating pools of strings to avoid concatenation. Presumably, a language designed to be a systems language could avoid these library problems.

I don't know much about Go, but if allocations are clearly demarcated and easily avoidable when necessary, you could allocate 100% of memory up front. You could treat virtual memory as an object pool of memory pages and perform domain specific allocation on those.

Alternatively, a collector with a richer interface, such as generation control, multiple heaps, etc. Would allow for "Path 2" (avoid latency) by performing very small, simple collections.

<comment><USER6> _> I'm not so sure there are applications which simply cannot tolerate garbage collection._

Things that need to be really seriously realtime, such as aeroplane pilot assistance AI, and medical equipment firmware, I think these cannot use stuff like GC because there is no room for the slightest deviation in performance.

<comment><USER7> > Things that need to be really seriously realtime

Real-time garbage collection (hard and soft) is not a work of fiction. Hell, the first papers on real-time GCs were in the 70s.

> I think these cannot use stuff like GC because there is no room for the > slightest deviation in performance.

IBM's Metronome (Bacon & al) is a hard real-time GC.

</comment></comment></comment></comment><comment><USER8> C is probably the most firmly entrenched programming language that ever existed, and it's not going away in the near future. One big factor here is the fact that all major operating systems are written in (and have core libraries to support) C. I think in order to "replace C", you'd have to develop an OS in the other language, and that OS would have to gain widespread adoption.

<comment><USER9> Google is likely capable of creating its own operating system (if you don't already consider Chrome OS a legit operating system).

<comment><USER10> > Google is likely capable of creating its own operating system

I don't think they are capable of such mistake ;-)

There are plenty of free more-than-good-enough OSs to build upon. Unless Google needs something more revolutionary than Plan-9, they don't need to create another OS.

The only reason I would find sane to develop an entirely new OS would be to use all these new shiny toys we got in specialized processors inside our computers. It would be awesome to have a machine with lots (hundreds?) of cores of varying capabilities that could be powered up or down according to load, with processes being transparently migrated between binary-compatible ones or between similar virtual machines hosted on diverse cores.

It's been a while since I have seen a cool new research OS.

<comment><USER9> In a sense, I agree, but I guess I'm applying Apple business practices to Google in my mind. If they create their own operating system, in their own language, they have essentially gained a large amount of control. Given that Google is the most popular search engine and many people want to use Google products, it wouldn't be too hard to gain the majority foothold. Google is even making a Chrome notebook!

<comment><USER10> I think it was more luck than anything else.

Apple was failing. It had an ancient and crufty OS and needed to find a new OS outside the company because it failed to develop one internally at least twice. They could go with BeOS, NeXT or MkLinux (I run MkLinux on one Mac in my collection). NeXT came with Steve Jobs bundled for free.

At that time, Apple leveraged its bets making Java development a first-class citizen. It was not clear whether Objective-C would gain any foothold because it failed to get traction during its NeXT years.

</comment></comment></comment></comment></comment><comment><USER11> I don't know that much about working on operating systms, but here's Linus Torvalds on maybe using Go in the kernal:

"Hey, I think Go picked a few good and important things to look at, but I think they called it "experimental" for a reason. I think it looks like they made a lot of reasonable choices.

But introducing a new language? It's hard. Give it a couple of decades, and see where it is then."

[http://www.realworldtech.com/forums/index.cfm?action=detail&...](http://www.realworldtech.com/forums/index.cfm?action=detail&id=110624&threadid=110549&roomid=2)

<comment><USER12> From Linus, that's practically a shining endorsement.

<comment><USER11> Yeah. I should have mentioned that the quote was in _marked_ contrast to the rants about the evils of C++ he had been delivering earlier in that thread.

</comment></comment></comment><comment><USER13> Is this person intentionally trying to make the C harder to read? What's with all the missing newlines? I didn't get past the first few examples, because the C was so unnecessarily difficult to read, I assumed the Go was in similarly bad style. (I don't know Go.)

Maybe there's a point in there somewhere, but bad code samples distract from it.

<comment><USER14> Agreed. Besides crappy formatting, he also makes his programs do confusing things. Why does the first example run in the infinite loop?

<comment><USER15> Because that's what the "yes" utility does:

"By itself, the yes command outputs 'y' or whatever is specified as an argument, followed by a newline repeatedly until stopped by the user or otherwise killed; when piped into a command, it will continue until the pipe breaks (i.e., the program completes its execution)."

<http://en.wikipedia.org/wiki/Yes_(Unix)>

</comment></comment></comment><comment><USER16> This is just a facet of a bigger issue: how come when you want a dynamically typed, scripting language you have plenty of choice but when you want an alternative to C/C++ (i. e. general purpose, compiled to actual machine code -- no VM, no GC), there is hardly anything (Fortran anyone?) If you add 'object-oriented,' you're pretty much left with C++ and, um, OCaml? Even when you want a functional programming language (still semi-esoteric in my book), you have more to choose from.

<comment><USER2> I bet there are many static typed, compiled languages. But they never get any traction because they are not "sexy" like the newest hyped dynamic language. There are many devs who don't care for static typing - they just want to hack their backend in a weekend and be done. Those devs seem to be the vocal ones with blogs and social media power users behind them.

Look at Python. Python is over 20 years old. It has been here since before Windows 95 but only got prominent (in the broad public) in the last few years because some opinion leaders of the hip and young crowd found out you could make cool web apps with it and hyped it into oblivion.

I bet if Go hadn't the names behind it it wouldn't get any more traction than any other of the gazillions of programming languages that die silently. I guess not many home brew languages get talking time at a Google conference.

Let's be just happy that Go seems to get a little popular - maybe it will be enough for a break through. I'd love that.

<comment><USER17> _Python is over 20 years old. It has been here since before Windows 95 but only got prominent (in the broad public) in the last few years because some opinion leaders of the hip and young crowd found out you could make cool web apps with it and hyped it into oblivion._

Hmm, I thought it became popular for scientific applications and as an anti- Perl for scripting before it became popular for web apps? I first got into Python because I needed a scripting language. People said, "If you don't like the design philosophy of Perl, then you might like Python, which made the opposite choices." The centerpiece of Python advocacy back in the day was this article by Eric Raymond: <http://www.linuxjournal.com/article/3882>

I know that's the article that convinced me to try Python. Everything he praised about Python screamed "opposite of Perl!" and after experiencing my mind rejecting Perl like a body rejecting a transplanted organ, I was desperate for an alternative that would make me as productive at scripting as the Perl gurus. (Yes, I'm still jealous of the one-liners.)

So there is certainly room for a language to grow and become popular without having a first-class web framework. (These days any popular language will sprout a few web frameworks, but they don't have to become popular for the language to succeed.)

<comment><USER18> Also IMO the ActiveState did alot to make perl & Python popular. Only in the last 10 years or so did ActivePython become really useful. In the last 90's it seemed (in my mind, at least) to play second fiddle to ActivePerl.

</comment></comment></comment></comment><comment><USER19> We used Go to re-write our cluster management system. In 2,000 lines, we have master and slave daemons that launch programs, exchange files, and forward output from running programs; "launcher" functionality in the same codebase allows users to start jobs and check the status of the system. Switching to Go made everything significantly easier.

<comment><USER20> I'm wondering why you didn't use a scripting language like Python?

<comment><USER19> 1\. We wanted to try out Go

2\. We wanted something that would give us a single, staticly-linked binary that we could easily push out to the nodes. Does Python allow that?

3\. Go's goroutines and channels fit beautifully with what we were trying to do.

</comment></comment></comment><comment><USER21> I see too many other languages defeating Go at its strengths. The only one that survives is its fast compilation, but others are not so slow to make that a deciding factor.

If you happen to like/need its particular combination of strengths it may be a good choice, but I think much better can be done. It's a good experiment, but I think they're taking it too seriously in some regards and not seriously enough in others. I just don't see it lasting.

<comment><USER22> I want a simple language that compiles to native code, has easy concurrency support, is garbage collected, allows me to distinguish between values and references, and has a compiler/standard library that is useable for real tasks. What other language betters fill that?

<comment><USER21> That depends. I don't have a good answer because I don't personally think Go qualifies. Rhetorically: _is that really all you want out of it? Does Go really do it well enough in your opinion?_

The thing about compiling to native code is interesting. Why is that important? And are you excluding VM languages which nevertheless produce system binaries in that?

</comment></comment></comment><comment><USER23> This seems like a case of premature optimization. C rocks at what it does. The billion other languages are pointing out and improving upon the stuff C does badly, but they don't replace C (a language I've nearly forgotten, but respect). I RTFA (and its subpages) and didn't see anything mindblowing.

The payoff of C->Go comes if you have 1M LOC of C. 900k LOC of Go is much better. For most of us, just-getting-it-to-run is awesome and that's why Ruby, Python, Lisp and Clojure dominate.

The best part of the post is that (until later) I didn't know that the "ooh- wow" bits on [http://www-cs- students.stanford.edu/~blynn/c2go/ch04.html#_f...](http://www-cs- students.stanford.edu/~blynn/c2go/ch04.html#_full_translation) were Go and were longer than their C equivalents. Sure, the C bits look scary to a noob; they look perfectly sane to a journeyman.

</comment><comment><USER24> How can a language with garbage collection _replace_ C?

<comment><USER25> Like you, I obviously don't grok Go. Is the goal to build a modern general purpose language? Or is it to build a better C?

I'm not sure how it can succeed at either when when it borrows a so much from C (a language which is at least a couple generations dated when it comes to general purpose languages) while adding garbage collection.

<comment><USER26> The purpose of Go isn't to replace C at what C does best, like being wicked fast and having very direct access to the hardware. It's meant to replace programs that Google used to write in C++, like web servers, data aggregators, etc. Go was designed by Googlers for Googlers, and that's very obvious from both the design and standard libraries.

</comment></comment></comment><comment><USER16> There is a lot to be gained by designing a language that is easier to use than C++ while being at least as fast and that's what Google is probably betting on. GC saves a lot of programmer's time and they don't care about tiny embedded systems not being able handle it. Examples of D and other alternatives only show you need a company behind a language to make anyone use it.

On the other hand, C can't be improved much without compromising the 'as much speed as possible but handle with care' philosophy (like introducing GC while sacrificing a bit of speed).

</comment><comment><USER27> If the title was "Could Go be used instead of C for a great many applications?" then the author would stand a chance at making a point. However, asking whether Go can "replace" C shows a deep misunderstanding of why people still use C: to do the type of stuff that a safe, typed and garbage collected language won't let you. Need to poke hardware? Need to use efficient memory layouts for your data structures that confound non-dependent type systems? Need exact control over generated code to achieve competitive performance? (And, apparently for Go's case) need to handle OOM conditions? (The "some systems don't even have malloc() return NULL on OOM" argument was particularly weak.) True, these things can be handled by C/C++ and called by Go through a FFI, but then C hasn't really been "replaced".

Really, the title should be "Can simple C programs be written in Go in about the same number of lines?" because that's all that was demonstrated.

</comment><comment><USER28> -1 to Automatic semicolon insertion (seriously).

<comment><USER21> Yup. I stopped following Go when that happened. Not intentionally but adding yet more things (invisible ones, no less) that I need to be wary of is not what I consider convenience in a syntax. Other more awkward languages became less inconvenient to use and I just stopped using Go.

I probably would have kept at it a bit longer if the dev team was more accepting of feedback presented in good faith. I'm not really surprised -- it's often hard to tell the difference between fruitless bikeshedding and _oh guys FYI you might consider this a problem, I do._

I am biased towards semis though, when I first saw OCaml's ';;' I was pleased.

<comment><USER28> I mostly stopped too. I still read the mailing list occasionally, but haven't bothered to download any snapshots.

</comment></comment></comment><comment><USER29>
        As a rule, never start a new line with an opening brace;
        it belongs with the previous line.

I'm always using the "one true brace style", so that wouldn't be a problem for me personally; however I feel the pain for people using BSD style. Using a consistent indentation and brace style across all languages you're working with, be it C, Java, Javascript, Perl, PHP is a must, and that Go idiosyncrasy seems really wrong to me; this kind of detail may hamper Go acceptance quite a lot.

<comment><USER30> I'm pretty sure you'd get used to it very fast. I think it's a good idea to enforce one style from the start: it kills all stupid arguments in the egg, and lets people focus on the important stuff.

</comment></comment><comment><USER31> Really? Systems programming with a garbage collected language? I'm sure the kernel developers will love that.

<comment><USER32> Why not have a systems language with garbage collection?

From <http://research.microsoft.com/pubs/52716/tr-2005-135.pdf>:

      3.4	Garbage Collection
      Garbage collection is an essential component of most safe languages,
      as it prevents memory deallocation errors that can subvert safety
      guarantees. In Singularity, the kernel and processes object spaces
      are garbage collected.

I appreciate that Microsoft Research is saying "why not?" rather than "why?". Singularity is a fascinating OS and I hope it, or some derivative or something like it from someone else, eventually reaches the mainstream market.

<comment><USER33> BitC, a project started by Jonathan Shapiro of Coyotos project fame and briefly associated with Microsoft's Midori project, is a systems programming language that supports garbage collection but also allows the programming of critical sections of code in which garbage collection is not permitted to take place.

<http://www.bitc-lang.org/docs/bitc/bitc-origins.html>

</comment></comment></comment><comment><USER34> I don't see a lot of buzz for Go or at least not nearly enough to make me even ponder "Could Go replace C?".

</comment><comment><USER35> Related: simple Unix tools written in Haskell. Most of them become just one- liners. Everything is linked to a single executable.

<http://www.haskell.org/haskellwiki/Simple_unix_tools>

</comment><comment><USER36> I'm surprised nobody has pointed out another major reason Go will not replace C: embedded programming. GC eats valuable kilobytes on hardware that often doesn't have any to spare.

<comment><USER37> It's all about trade-offs. GC does eat more memory but with the proliferation of reasonably sized chunks of RAM on ARM embedded systems for example, it's of little concern. Not only that, you reduce the time to market and likelyhood of your code falling over due to pointer and memory problems. That is probably preferred (in my experience) when your product is in situ and has no form of upgrade possible other than shipping an engineer out to do it.

<comment><USER36> The cheapest ARM chips are still total overkill for most retail embedded electronic devices and many times more expensive per unit.

The cheapest ATTiny AVR chip is $0.60/ea bulk. The cheapest ARM chip like an AT91 is about $4.00/ea bulk. Ship a few million units and suddenly the cost difference between developing in C and Go is pittance.

</comment></comment></comment><comment><USER38> I'm no CS guru, but just reading the Go code makes me long for the C examples. Thankfully they are not far up the page. Aaahhh...

</comment><comment><USER39> Serious question. Does Go really have anything unique going for it, apart from the fact that it comes from Google?

I have yet to see a convincing argument why I should choose Google's little (and relatively immature) language over anything else and I'm very close to assuming this thing is pure hype and has nothing actual newsworthy. Ofcourse, as always I'd love to be proved wrong.

<comment><USER37> It's as easy and as expressive as python, nearly as fast as C and less complicated than both. That's good enough in my book.

<comment><USER40> _nearly as fast as C_

not quite; using comparisons from the The Computer Language Benchmarks Game [[http://shootout.alioth.debian.org/u32/which-programming- lang...](http://shootout.alioth.debian.org/u32/which-programming-languages- are- fastest.php?gpp=on&gcc=on&java=on&ghc=on&csharp=on&go=on&racket=on&python3=on&yarv=on&calc=chart)], Go is currently (in general) slower than C++ gnu g++, C gnu gcc, Java 6 -server, Haskell GHC, C# mono, just to name a few. Sure, it's not a definitive view, but it's better than code not run and compared.

<comment><USER41> Go's compilers are still very young and do almost no optimizations.

Also, the 32bit compilers are specially bad as they are not really used by most of the Go developers, the 64bit compilers do much better as you can see here:

[http://shootout.alioth.debian.org/u64/which-programming- lang...](http://shootout.alioth.debian.org/u64/which-programming-languages- are-fastest.php)

<comment><USER42> There is also gccgo, which uses (and profits from) the gcc backend.

</comment></comment></comment></comment></comment><comment><USER43> Really? Replace C? Really? <http://golang.org/src/>

</comment><comment><USER44> eww, single character variable and function names make me ill

</comment><comment><USER45> Go is designed more like a language for the web. it has a special niche in server programming with ease in memory management and concurrency.</comment>


Ask HN: If you could mold a developer that gets the job done, how'd you do it? - <AUTHOR> If personality and work experience were perfect, and you had absolute power over an individual prior to him working for you (think freshman year or high school) - how would you mold him/her? What concepts would you want him/her to know? What principles and best practices should he/she follow? What languages (limit to 2,3)?
Essentially - even though this question was asked numerous times in different forms and on different web sites - I feel all of them lack something. They either point you to learn x and then learn y. Learn about this principle and then about this. No one puts it together - they just throw around books, websites, tutorials. And while that is helpful to a point, fitting it together can sometimes be puzzling.
So, how would you mold and shape your perfect developer? (any type applies) <comment><USER2> Clone myself</comment>


Why Facebook's Mark Zuckerberg returned to writing code - <AUTHOR> http://timesofindia.indiatimes.com/tech/social-media/Why-Facebooks-Mark-Zuckerberg-returned-to-writing-code/articleshow/13301639.cms <comment><USER2> I'd be interested to know how he's doing on the other pledges he's made.

</comment><comment><USER3> <http://hackertyper.com/></comment>


I ate lunch with my co-founder over video - <AUTHOR> https://pragli.com/blog/i-ate-lunch-with-my-co-founder-over-video/ <comment><USER2> A complaint I've heard from my remote coworkers is: "Yeah, I like to have lunch with ya'll when I'm there. But when you're remote, like, the whole day is just sitting staring at a computer. The last thing I'm interested in is having my lunch/eating time be more of that". Have you considered doing something along the lines of real walks "together", using headphones?

<comment><AUTHOR> I haven't - but that's a good idea! Might have to do another post...</comment></comment>


I have import some Macbook decal from China and use shopify build a online store - <AUTHOR> http://skinatus.com/ <comment><USER2> You should get someone well-versed in English to give your site a copy check - there are a few 'ESL' errors in there.</comment>


HaXe - haXe Introduction - <AUTHOR> http://haxe.org/doc/intro <comment><USER2> Sample code! Sample code!

Why do language web sites so frequently omit samples of the language? It should be right there on the intro page, just to give me a feeling for the language.

<comment><USER3> I agree. I looked on <http://haxe.org/doc> and it took some searching to finally find "Code Snippets" <http://haxe.org/doc/snip> and then go to that page... which still has no code, but is just a list of examples, each on their own page. So, finally, yet another click later, <http://haxe.org/doc/snip/hello> is the Hello World, and you can see the rest on the snippets page.</comment></comment>


Applying the Unix Philosophy to Object-Oriented Design - <AUTHOR> http://blog.codeclimate.com/blog/2012/11/28/your-objects-the-unix-way/ <comment><USER3> The post is essentially another take on the Single Responsibility Principle. It's a good principle, and Rails model classes are also a good choice of an example where it's frequently violated.

Rails practically _begs_ you to disregard SRP in your models. It entices you to put all your validation logic, relationship specifications, retrieval logic and business logic into one gigantic basket. Under these circumstances "fat models" become "morbidly obese models".

Rails 3 introduced "concerns" as a means of organizing the bloat into mixins. These are a testability nightmare. There doesn't seem to be any clean way of testing concerns without instantiating one of the model classes that include them.

The only way to use ActiveRecord without sacrificing testability, SRP, and the OP's application of "the Unix philosophy to Object Design" seems to be by limiting usage of it to to a pure persistence layer. But doing so seems to preclude using most of the ActiveRecord features that make it so convenient in the first place. Can anybody set me straight on this somehow? I would love to be completely wrong about everything I've just written here.

<comment><USER4> You may want to checkout this short book by Giles Bowkett: [http://gilesbowkett.blogspot.com/2012/11/i-wrote-ebook-in- we...](http://gilesbowkett.blogspot.com/2012/11/i-wrote-ebook-in-week.html)

It goes into the areas (like AR models) where Rails breaks the classic "OOP Golden Rules" and why it is able to get away with it in some cases.

<comment><USER3> I've just had a look at the free excerpt and I think you might have made the most perfect book recommendation I've ever seen. A bit on the expensive side, but it'll be good to get a fresh perspective on this after perhaps a little too much Uncle Bob lately.

Thanks!

</comment></comment></comment><comment><USER5> > UserContentSpamChecker.new(content).spam?

Noooooooooo !

Sorry. There is no purpose for these layers of indirections since you're never passing the instance around to share state. If UserContentSpamChecker where a value object you could have argued that you're doing a form of casting but it's not. Best is to stay with a simple function:

        module UserContent
          extend self

          TRIGGER_KEYWORDS = %w(viagra acne adult loans xrated).to_set

          def is_spam?(content)
            flagged_words(content).present?
          end

          protected

          def flagged_words(content)
            TRIGGER_KEYWORDS & content.split
          end
        end

Now you can just call the function directly:

> UserContent.is_spam?(content)

<comment><USER6> I see this assertion increasingly frequently, and it puzzles me: that if we're not currently using an object to encapsulate state, we should prefer class methods. What's the justification? Other than four characters saved (".new"), what's the benefit in this approach?

State encapsulation is just one feature of objects. We may not be using it right now, but the only thing you achieve with the above code is removing future flexibility. It costs us nothing to allow for the future possibility of encapsulated state, so why rule it out? Adding complexity when you don't yet need it, fine, I quite understand objecting to that; but here you're actually putting in effort to make a future modification more difficult.

Funnily enough, Code Climate's previous blog entry was on precisely this topic, and is worth a read:

[http://blog.codeclimate.com/blog/2012/11/14/why-ruby- class-m...](http://blog.codeclimate.com/blog/2012/11/14/why-ruby-class- methods-resist-refactoring/)

For what it's worth, I don't see the point in instantiating a whole new spam checker for every piece of content, so I'd probably change the OP's example to read:

        class UserContentSpamChecker

          TRIGGER_KEYWORDS = %w(viagra acne adult loans xrated).to_set

          def is_spam?(content)
            flagged_words(content).present?
          end

          protected

          def flagged_words(content)
            TRIGGER_KEYWORDS & content.split
          end
        end

If I really really wanted access to a default spam checker via a global constant I can always add the following:

        class UserContentSpamChecker
          def self.is_spam?(content)
            new.is_spam?(content)
          end
        end

At least then if my UserContentSpamChecker class ever has to change (perhaps it starts to use an external spam-checking service that's injected through the constructor), then I only need to change code in one place. And other clients that might want to inject a different spam-checking service (or a test double) are perfectly able to.

<comment><USER5> I think that we agree on the bottom-line: UserContentSpamChecker has no need for a state and is just some kind of namespace. That's the point that I wanted to get trough.

Then we can argue on the best way to handle that namespace. I'm not particularly fond of the class method approach neither but I don't think that your approach is appropriate either. A namespace should be instantiated only once in my opinion, that's why I'm going for the singleton object. Maybe the problem is with ruby and it should provide another mechanism for managing namespaces ?

        UserContentSpamChecker = namespace do
          TRIGGER_KEYWORDS = %w(viagra acne adult loans xrated).to_set

          def is_spam?(content)
            flagged_words(content).present?
          end

          protected

          def flagged_words(content)
            TRIGGER_KEYWORDS & content.split
          end
        end

        class MyOtherClass
          import :spam_checker, UserContentSpamChecker

          def foo
            spam_checker.is_spam?(content)
          end
        end

<comment><USER7> Keep in mind that in Ruby, classes and modules are just ordinary objects that happens to be instances of the classes Class and Modules respectively.

So for all practical purposes, if you define a module it is not much different than if you define a class, and then instantiate a single object (it is _slightly_ different in that your object will be an instance of your class rather than of the class Class).

Modules _are_ namespaces for Ruby (and pretty much only differs from classes in that you can't create instances of modules)

What you describe above is done with modules:

        module UserContentSpamChecker
            def is_spam?(content)
                ...
            end
        end

        class MyOther Class
             include UserContentSpamChecker

             def foo
                 is_spam?(content)
             end
         end

If you want to be able to alias it, you'd do it with a method:

        module UserContentSpamChecker
            def self.is_spam?(content) # note the "self." to define a method callable on the UserContentSpamChecker object itself (of class Module)
                ...
            end
        end

        class MyOther Class
             def spam_checker; UserContentSpamChecker; end

             def foo
                 spam_checker.is_spam?(content)
             end
         end

(or you could do it with a class variable or class instance variable - <USER2> class variable:)

         class MyOtherClass
              @@spam_checker = UserContentSpamChecker

              def foo
                  @@spam_checker.is_spam?(content)
              end
         end

<comment><USER5> I find that modules are good to add behaviour to an object like Enumerable but I don't find them practical as a namespace holder.

Including is an all or nothing operation. In your first example #is_spam? is now also a public method of MyOtherClass. The other issue with module includes is that method name collisions are also much harder to debug.

I also like your second example but I think it would be clearer if :spam_checker had a dedicated semantic. Something like:

        class Module
          def import(name, obj); define_method(name) { obj }; protected(name); end
        end

</comment></comment></comment></comment></comment><comment><USER8> The tldr of the article is to write modular code. This is great advice, I hope most intermediate software engineers already live by this.

If I recall my CS history correctly, Multics/Unix was one of the first major software projects that embraced the modular philosophy. But modularity is a natural approach when designing large systems, and has been embraced by electrical and mechanical engineers for way longer than software systems have existed. Modularity even extends to processes; Henry Ford made his millions by modularizing the assembling process of his cars.

<comment><USER9> ... and hardware engineers as well. It is the usage of hardware pipelines that makes possible GHz processors nowadays. It is a really wide concept that can be applied to several kinds of processes.

</comment></comment><comment><USER10> It's a nice idea, but look at how much code you have to write to obtain this decoupling.

The "mental" abstraction is nice to have, but when you end up typing _more_ characters, it's just counterproductive.

Once you start repeating yourself, then it makes sense. To do it from the start is overengineering—"you ain't gonna need it".

<comment><USER11> Your argument taken to the extreme leads to code golf.

Sure abstraction is worth it. You get code reusability, better unit testing, and faster understanding of the code.

Maybe a small script doesn't need it, but once something starts growing past a few hundred lines you're better off.

<comment><USER12> Nobody suggested taking his argument to the extreme.

A larger script might indeed need it, but knowing when you need abstraction and when you don't is key. In this case, YAGNI.

</comment></comment></comment><comment><USER4> Maybe it's because I've been reading about DCI lately, but I think this example could go even further in moving business logic out of the AR model.

        class GuestbookLibrarian
            def initialize(rate_limiter, tweeter, spam_checker)
                @rate_limiter = rate_limiter
                @tweeter = tweeter
                @spam_checker = spam_checker
            end

            def add_entry(name, msg, ip_addr)
               raise PostingTooSpammy if @spam_checker.is_spammy? msg
               raise PostingTooFast if @rate_limiter.exceeded? ip_addr

               entry = GuestbookEntry.create(:name => name,
                                             :msg => msg,
                                             :ip_addr => ip_addr)
               @rate_limiter.record(ip_addr)
               @tweeter.tweet_new_guestbook_post(name, msg)

               entry
            end
        end

        class GuestbookController < ApplicationController
            ... SNIP ...

            rescue_from PostingTooSpammy, :with => :some_spam_handler
            rescue_from PostingTooFast, :with => :some_other_spam_handler

            def create
              #maybe these should be globals in an initializer somewhere if we
              #use them elsewhere? or in a :before_filter at least :)
              rate_limiter = UserContentRateLimiter.new
              tweeter = Tweeter.new
              spam_checker = UserContentSpamChecker.new

              librarian = GuestbookLibrarian.new(rate_limiter, tweeter, spam_checker)
              entry = librarian.add_entry(params[:name], params[:msg], params[:ip_addr])

              redirect_to entry, :notice => "Thanks for posting"
            end
        end

Something like that? Too Java-y? Feedback appreciated :)

<comment><USER13> Interesting approach. It'd be a bit surprising in a Rails app, however, since models usually handle their own validation.

That said, the fact that GuestBookEntry doesn't have validation as a concern does make it simpler.

I _might_ refactor to something like this if a particular model had extremely complicated validation logic, but wouldn't ever do this as a first pass.

<comment><USER4> I think in general models can handle their own validation (especially if you use AR), but I guess the difference is that these validations hit external "services", instead of like a :max_length validation.

I agree on the first pass comment - I imagine that the user stories went something like:

        * v1 - An anon user can post to the guestbook
        * v2 - Guestbook comments are checked for spam
        * v3 - Post guestbook comments to twitter for Web 2.0-ness

And this is the refactored version after v3

</comment></comment></comment><comment><USER14> Yet the refactored example is still showing application domain logic being built within the web framework. For simple applications that are only ever going to be delivered via the web and only ever rely on one particular web framework this might be ok. That being said, I'd like to see movement away from this back to using web frameworks or anything else simply as the communication platform between your application and the user.

<comment><USER15> Good point. There's some good discussion in the Rails community about ports- and-adapters architecture around that theme. Matt Wynne gave a talk at goruco this past year on the subject that's worth checking out: [http://www.confreaks.com/videos/977-goruco2012-hexagonal- rai...](http://www.confreaks.com/videos/977-goruco2012-hexagonal-rails)

</comment></comment><comment><USER16> The Microsoft Word example is not entirely accurate. Most office application _are_ in fact having well defined interfaces through OLE [1]. This works in several languages like Perl, VB, Delphi or Python.

[1]: <http://www.adp-gmbh.ch/perl/word.html>

<comment><USER17> good point.. it's not because the application itself seems monolithic the underlying strcuture is.

Apart from that, how on earth would the author go about teaching an average Joe-that-wants-to-type-a-letter that instead of having to open a single program and start doing everything he can imagine, he now has to use 100 seperate programs each entitled to a certain task?

</comment></comment><comment><USER18> Wow, I didn't realize the McIlroy who critiqued Knuth's famous literate program also conceived of shell pipes in the first place: <http://www.leancrew.com/all-this/2011/12/more-shell-less-egg>

</comment><comment><USER19> I don't particularly see the unix philosophy ever shining through in object oriented design. The problem is that objects are too inflexible - you can't just glue methods together, piping arbitrary objects into methods like you can do with data at a command line prompt.

</comment><comment><USER20> While this is certainly useful, it's pretty basic. Something that I find is a much closer fit to UNIX pipes is iterators. UNIX pipes work similarly in that all of the commands in the pipeline are executed in "parallel" and the OS passes data incrementally between each process.

I primarily work on a Python codebase, and I've found that using iterators for complex, fault-tolerant data pipelines allows decoupled design without many of the performance & additional complexity drawbacks often encountered with cleanly abstracted, decoupled code. For example, when executing a multi-get for objects by primary key, the pipeline looks roughly like this:

1\. Fetch from heap cache

2\. Fetch from remote cache

3\. Fetch from backing store

4\. Backfill the heap cache

5\. Backfill the remote cache

6\. Apply basic filters (e.g. deleted == False, etc)

At each step there are usually two or three layers of abstraction underneath. Much of the space requirements, and some of the overhead time at each step can be collapsed to O(1) instead of O(N).

For example, a cache multiget abstraction on-top of memcache might look something like this:

        def deserialize_user(serialized_user):
            return json.loads(serialized_user)

        def build_prefixed_memcache_key(prefix, key):
            return "%s:%s" % (prefix, key)

        def get_users_from_remote_cache(user_keys):
            cached_users = get_from_memcache(user_keys, "user")
            deserialized_users = {deserialize_user(value) for key, value in cached_users.iteritems()}
            return deserialized_users

        def get_from_memcache(keys, prefix):
            rekeyed = {build_prefixed_memcache_key(prefix, key): key for key in keys}
            from_memcache = []
            for chunk in chunks(rekeyed.keys(), 20):
                results = memcache_mget(chunk)
                from_memcache.extend(results)
            unkeyed = {rekeyed[key]: value for key, value in from_memcache}
            return unkeyed

Notice how at each step there is a large amount of "buffering" that causes allocation, copying, and quite a bit of additional work. Each layer of abstraction adds a pretty large cost to the step. Using an iterator implementation, we can clean up this code and make it more performant:

        def get_users_from_remote_cache(user_keys):
            for key, user in get_from_memcache(user_keys, "user"):
                yield deserialize_user(user)

        def get_from_memcache(keys, prefix):
            for chunk in ichunks(keys, 20):
                rekeyed = {build_prefixed_memcache_key(prefix, key): key for key in chunk}
                for key, value in memcache_mget(rekeyed.keys()):
                    yield (rekeyed[key], value)

It's clear how much cleaner this code is. Notice how this snippet avoids the large amount of "buffering" of data between steps and short-circuits quite a bit of code when possible (for instance, if all of the fetches miss). In real code that's heavily abstracted & layered, avoiding all of this work translates into significant performance & cost advantages.

Iterators also allow building portions of the pipeline with built-in functions that avoid the interpeter.

        def deserialize_users(users):
            return imap(pickle.loads, users)

        def get_users_from_remote_cache(user_keys):
            cached_users = get_from_memcache(user_keys, "user")
            only_values = imap(itemgetter(1), cached_users)
            return deserialize_users(only_values)

This block of code executes in only one pass through the interpreter (imap, itemgetter, and pickle.loads are all implemented as native functions). This is incredibly powerful because it means that iterator-based abstractions can be built by combining these native building blocks without the overhead of recursion within the interpreter at each step.

Pushing all the recursion into native code:

        def gprefix(prefix, delimiter):
            prefix_with_delim = prefix + delimiter
            prefixfn = partial(add, prefix_with_delim)
            unprefixfn = itemgetter(slice(len(prefix_with_delim), None))
            return prefixfn, unprefixfn

        def memcache_mget_chunked(keys):
            chunks = ichunks(keys, 20)
            result_blocks = imap(memcache_mget, chunks)
            flattened_results = chain.from_iterable(result_blocks)
            return flattened_results

        def get_values_from_memcache(keys, prefix):
            prefixfn = partial(add, "%s:" % prefix)
            prefixed_keys = imap(prefixfn, keys)
            key_pairs_from_cache = memcache_mget_chunked(prefixed_keys)
            values_from_cache = imap(itemgetter(1), key_pairs_from_cache)
            return values_from_cache

* I apologize for any code errors, this code wasn't tested in it's entirety.

<comment><USER21> (Minor nit: the yield-based functions are generator functions, not iterators.)

This approach was also described by David Beazley at PyCon, the slides are available at <http://www.dabeaz.com/generators/Generators.pdf>. He extends this approach to generator multiplexing, coroutines etc., along with useful examples. An excellent read.

</comment></comment><comment><USER22> This is the principle to always create loosely coupled components that can be glued together.

I think the OO community has already learned that interfaces, categories, traits, mixins, or whatever they are called in your favorite language, favor more re-usability than plain inheritance.

The trick is to learn when inheritance, delegation or composition make sense.

As with everything in life, it takes time to proper learn them with lots of failed experiences along the way.

</comment><comment><USER23> Quite a long (although interesting) article. tldr version: <http://tldr.io/tldrs/50b62f8abb22039977000471>

</comment><comment><USER24> > write programs that do one thing and do it well. Write programs to work > together.

ASIDE: Just been reading _The Wealth of Nations_ , and Smith talks about the "division of labour", which is similar to this specialisation. By concentrating on one task, a workman can increase his dexterity at it, not waste time switching between tasks, and find ways to do it better. "Do one thing and do it well" is a pithy exaggeration of this specialisation.

This division of labour is only possible because of trade: other workmen do the tasks that you aren't doing, and you barter with each other to get what you each need. Because you specialised, you each do your own task more efficiently, so you are both better off. Programs that "work together" is similar, because if you couldn't use another program, you'd _have_ to include it in the first program. "Programs" would also include 3rd party libraries and frameworks I think.

He goes onto say that one limitation on how much labour can be divided is the market size: you to be able to trade what you make. If people don't need much of what you produce, you've over-specialised. However, if you have access to a large enough market, then in aggregate, with many people using a little bit, you can survive. Larger markets therefore allow more specialisation, and therefore more wealth. Rich civilisations grew up around navigable rivers (especially with canals), and inland seas (calmer and safer to navigate than the open ocean), because water-carriage facilitates trade with more people (larger market), over larger distances, at lower transport cost and less risk.

Does the analogy fall down with free programs, since you won't go out of business just because few people use it? Open source projects _do_ seem to need users, for encouragement, bug reports, spreading the word, contributing bug fixes etc - users pay in attention, not money. Without attention, projects die.

Does the analogy fall down when it's the same person writing all the separate programs? You can certainly specialise, and therefore do a better job; and also "exchange" data between those parts. (Provided of course that specialisation is actually more efficient, and outweighs the costs of exchange). But the motivation doesn't apply in quite the same way, since the parts of the code don't get paid - not in money, not in attention. You're more like a communistic planned economy (or, within a firm).

But the interesting point I've been leading up to is: does a larger market for programs lead to greater specialisation? For example, Java has a large number of users, and has a ton of 3rd party programs - and that does seem to include very specialised libraries.

Or, are other factors at work, leading to more one-package programs, such as Word; or dividing the market into smaller ecosystems, such as Java itself, and also other languages python/ruby/PHP, and even frameworks, like RoR. There are barriers between these "markets", in the extra difficulty of using library from one platform in another. For example, for JS, I get the impression there are many libraries for doing the same web/forms/template etc. While competition is healthy, and these frameworks are definitely improving on each other, they aren't the "division of labour" of interest to this particular discussion.

In programs, does a larger "market" of fellow coders result in more specialisation in the "one thing" done well?

<comment><USER25> A program doesnt getter better by doing the same task over and over again ( and i disagree with A.Smith anyway , a factory worker doesnt choose what process he is going to use to acheive his task , no matter how many times he executes his task , the way he has to work is decided by his boss, A.Smith is and has been proven wrong on many things like the invisible hand");

<comment><USER26> I've never read _The Wealth of Nations_ , but Smith wrote well before the industrial revolution. So when he spoke of workers, he was referring to tradesmen and craftsmen. For them, specialization does allow them to get better by performing the same tasks over and over again.

In a way, the industrial revolution just changed the scope of his arguments, but I think the basic idea still holds. Now, instead of thinking in terms of a single worker, we could instead think in terms of a single factory. Each factory, comprised of many workers, would then be able to perform one specialized task well, and trade for the rest. It would be up to each factory to organize itself in an optimal manner.

In thinking in terms of a program, it wouldn't be the program that gets better, but the programmer. If they write a program to perform task X multiple times, that program will inevitably get better with each iteration. So, ideally, what you end up with is a series of optimized programs that can work together in different configurations in order to perform different tasks in the most efficient way.

At least, that would be the theory. I'll leave discussions of the invisible hand of the market for later :)

</comment></comment></comment><comment><USER27> Unix philosophy has nothing to do with objects. It is about _interfaces_ , _streams_ and common intermediate data representation - _plain text_.

Scheme or Erlang are _real_ examples of following similar philosophy.

Modularity is much more basic concept, underlying any software. It is about spiting code into blocks for later reuse, named, in case of procedures, or anonymous in case of blocks or lambdas.

The notion that smaller, share-nothing procedures doing only one well-defined task are better than bloated and close-coupled ones is a general one.

So, do not try to mislead others. There is nothing from UNIX Philosophy there, just a basic concept of modularity.

<comment><USER26> Nobody is claiming that the Unix philosophy depends on objects. The author was trying to claim that applying some Unix principles to Object Oriented Programming would be beneficial.

 _Do one thing, and do it extremely well_ is a simplified version of the Unix design philosophy. And this can be applied various levels of abstraction, including within OO programs.

I fail to see the controversy in this.

<comment><USER28> It doesn't become really controversial until someone points out that unclassed functions are the logical extreme of this philosophy at which point the predictable shit flinging starts.

</comment></comment></comment><comment><USER25> Well , maybe the author should have figured out that the way Unix works is closer to functional programming than object oriented programming, before writing this blog.</comment>


Whistleblower sent 50GB mails from Germanys #1 dating app claiming massive fraud - <AUTHOR> http://www.heise.de/newsticker/meldung/Verdacht-auf-Abzocke-bei-Dating-Plattform-Lovoo-2821077.html <comment><AUTHOR> Some more background (article is in German, use Google Translate):

\- The whistleblower sent 50GB emails and screenshots to c't that so-called 'promotors' lured customers into upgrades

\- c't / heise.de is Germany's most reputable tech publication / publisher

\- After c't reported the fraud Lovoo denies and tries to damage c't's / heise's reputation by writing other major publications (see end of article, update 1) that heise doesn't work properly

\- This is really heavy because Lovoo and his CEO Benjamin Bak were partied for many years, they haven't taken any VC money and make 8 digit revs</comment>


We are not joking around with Open Source - <AUTHOR> http://zurmo.org/features/no-joke-open-source-crm

<comment><USER2> great article</comment>


Ask HN: Gang downvotes? - <AUTHOR> It seems a common tactic lately for people who disagree on a certain topic to go ahead and downvote indiscriminately all other posts by the disliked user as far back as they are able.<p>I don't really give a shit, given that these are just Internet points, but it seems against the spirit of HN as I know it. I would happily downvote people saying dumb shit, while simultaneously upvoting their relevant posts <comment><USER2> 1) I'm guessing this happened to you, which is why you brought it up.

2) You do "give a shit," or you wouldn't have posted this. I think it's normal to care when people downvote your comments, which is why votes work in the first place. Most of us probably care, as silly as it is.

3) Looking back through your votes, you don't seem to have been heavily downvoted except for saying the minimum wage has reached absurd levels (which is false, if you adjust for inflation) and that gun violence is higher in places with stricter laws (by mentioning which, you seem to have gotten cause/effect mixed up -- places with more gun violence have strengthened their laws as a reaction).

I think that the combination of your username and saying demonstrably false things has caused the behavior of going through your history and downvoting you. Some people don't want you here. I would say being strictly factual and somewhat tribal is very much in the spirit of HN (for better or worse).

<comment><USER3> But I think he may be right, at least about being downvoted indiscriminately. I feel targeted by an action like that for several weeks. It's irritating and tiring, as usual comments that half a year ago wouldn't warrant a downvote trigger one now.

Though in my case it doesn't seem to be a group, just one individual.

<comment><USER2> Same thing happened to me once (an individual). Nothing you can do about it, I guess. This isn't Reddit where you can just find a new sub.</comment></comment></comment>


One time job for fixing Wordpress or Squid or related infrastructure - <AUTHOR>

Are there any Wordpress/Squid/Linux experts in the house?  I have an issue with Wordpress where it is not going out through my outbound proxy (Squid). I am willing to pay a reasonable sum to anyone who fixes this issue.  Please contact me here or at infiniteseeker at gmail<p>Thanks <comment><USER2> Dropped you an email.</comment>