.NET Culture Shock: Why .NET Adoption Lags Among Startups - <AUTHOR> http://www.aaronstannard.com/post/2010/07/03/NET-Culture-Shock-Why-NET-Adoption-Lags-Among-Startups.aspx <comment><USER2> To be brutally honest about .Net, and I use it and like it myself, the reason there's no startup market in it is because until MVC there was no point developing in it.

ASP.Net controls, postbacks for everything, view state, a general hiding of the actual power of ajax and an obsession with using tables made .Net a terrible web development environment if you had any clue what you were doing. The html it spat out was a bloated horrible mess, web services were anything but unless you really slogged your way through some pain, ashx pages and the directory structure just felt plain wrong.

That said I'd almost, almost, switched to using python/django and then I had a look at MVC and it did everything I needed. Full control over html, nice code separation, a nifty ORM for taking away the pain of basic crud. An alright templating system easily extensible using extension methods. And 3.5 brought some tricks using LINQ and anonymous methods.

I still know I need to learn a few more languages, but MVC has allowed me to copy everything I felt was the 'right' way of developing webs apps from rails/django without having to actually learn a new language and dev environment.

If you weren't worried about performance and didn't want to learn how to actually program, the old ASP.Net was ok for very quickly throwing out web apps for the 10 people in HR. Much more than that required an in depth of knowledge way beyond most .Net programmers, with most of those people being multi-lingual anyway and tending to opt for the cleaner code the alternatives offered.

I don't feel that's the case anymore, but it's way behind in adoption at the moment.

You still hit the occasional WTF in MVC where if feels as if someone wrote a part of the system without reading the memo about flexibility (the validation solution in MVC, for example, is terrible, although not finished and LINQ to entities can be frustrating).

tl;dr;? No startups because until recently good web development in .Net was actually really hard. MVC's changed that.

<comment><USER3> This is false because it relies on an incorrect assumption: that if you were using .NET to do web development prior to MVC, you had to use ASP.NET.

When I was writing .NET web applications, the sum total of ASP.NET integration was implementing IHttpHandler and friends - not much more than access to the request and response streams. You can build your own lightweight framework, which, being lightweight, isn't a big deal.

<comment><USER4> +1 for this. We've been working in C#/ASP.Net for 7 years now, and we always stayed as far away from ASP.Net controls and Web Forms as possible. Some things we liked such as master pages and making a class hierarchy for the pages to inherit, so we used that.

For the past two years we've been using our own light-weight MVC framework.

C# and IIS are very versatile technologies, you don't _have to_ buy into the entire Microsoft tool chain to use it, you can use whatever parts you want.

<comment><USER5> This is true, but it also reinforces the statement that WebForms suck. It was so broken, that you had to write your own framework to deal with it.

<comment><USER4> To be fair, ASP.Net was a better technology than JSP, which were the main competitors back then. On top of ASP.Net, Microsoft built Web Forms, which is really bad when it comes to building large, scalable web applications. Unfortunately, Microsoft kinda stopped there, whereas the Java community continued and made Struts and Spring and whatever else they do now.

And that highlights the other problem with using the Microsoft stack: There's no community around popular frameworks, the absolute majority use only what comes out of Redmond, and if nothing comes, then they're just stuck.

In the Java community, there were loads of MVC frameworks, people built it, and the popular ones flourished, and people could move on. In the .Net community, nothing really happened until Microsoft themselves made an MVC framework.

So being on the Microsoft stack is more like a roller-coaster than a smooth progression, and that is a problem, because it's not very startup-friendly.

</comment></comment></comment></comment></comment><comment><USER6> I've been to 2 dotNet local conferences already ... the presentations are centered around Office / Sharepoint integration, plus company-sponsored propaganda (also targeted at the enterprise) that made me wanna` puke out of boredom. Even the presentation on Silverlight was focused on data-binding and how easy it is to build boring forms out of clicky-clicky actions.

This is especially telling considering I did work for "the enterprise" and I'm still doing it as a consultant.

Of course, personally I don't need more propaganda and advocacy.

Just last month I created an app for managing the webcams of a client. I used Red5 (the open-source Flash streaming server), in combination with Apache / Django + a MySql database. Besides my billing per hour, the extra cost to the client for the licensing of this infrastructure was $0.

And for my app, while I would love some of the stuff in .NET, I don't want to pay extra for those Windows servers, even if they provided extra-value over Linux (which they don't).

Putting your business hat on ... as a startup or as a pragmatic consultant, paying extra for Windows servers is not worth the price, unless the cost of switching from .NET is big (and really ... which other technology has such a big cost of switching?).

Sure ... it's easier to blame the lack of advocacy. The Perl community is also doing it (and I would rather go with Perl apps hosted on Linux servers than suffer the Windows licensing hell).

<comment><USER7> Have you taken a look at Mono? The Windows servers aren't always required. There are definitely some caveats but it might be an option.

<comment><USER8> I was surprised to install PHDVirtual's backup software and it involves two linux virtual machines which run a web interface based on .aspx.

I think it's the first time I've met Mono in a product.

</comment></comment></comment><comment><USER9> As someone who has done both Enterprise .NET and startup work, I have to say that the reason we didn't use .NET is much the same as the reason you don't rent a 2-ton backhoe to dig up a flower bed: cost and overkill.

Yes, the backhoe might dig the flower bed faster, but it costs $5,000.00 to rent, there's a one-week minimum rental, and its treads tear up your yard to get to the flower bed. On the other hand the shovel may be slower, but you can borrow one from a friend and it doesn't tear up your whole yard. Let's near in mind these are start-ups with limited capital and no time to fill in the holes that your treads tore up in your front yard.

<comment><USER4> The only thing you really need to pay for is the actual Windows 2000-whatever servers with IIS, everything else you can get for free. Visual Studio Express Edition is free, the .Net framework is free, and you can integrate with all sorts of popular open source products such as MySQL, Postgres, memcached, Cassandra, etc.

<comment><USER10> My time doing deployments and dealing with Windows Server issues is not free. Neither is the time lost using RDP instead of SSH, dealing with licenses, requiring much more HD space than the alternatives, and lacking real scripting solutions.

I have yet to hear anyone using LINQ on anything that's not SQL Server, and considering the NIH syndrome in Microsoft, I wouldn't recommend it.

<comment><USER4> _My time doing deployments and dealing with Windows Server issues is not free._

We don't have any issues with our Windows servers, but I guess the number of issues you run into is proportional to your experience. We would have a lot more problems dealing with Linux servers. YMMV.

 _Neither is the time lost using RDP instead of SSH_

Practice makes perfect...

 _dealing with licenses_

What? You buy it, you install it, done?

 _requiring much more HD space than the alternatives_

Now you're just being silly. Are you worrying about HD space in this day and age? Seriously?

 _and lacking real scripting solutions._

I'll give you this, but I've yet to see the need for such an environment.

 _I have yet to hear anyone using LINQ on anything that's not SQL Server_

Don't use it then? I think LINQ is a horrible idea, and horribly implemented, so I'm staying far, far away from it. I would never use it or SQL Server in a startup, that would be insane.

I see how you could accidentally recruit someone who thinks it's the best thing EVER and starts using it all over, but recruiting people addicted to the wrong bleeding-edge technologies is a hazard no matter which technology you use.

<comment><USER11> Have you even looked at how much bandwidth RDP uses compared to SSH? I can have 7 or 8 ssh connections open and monitoring files where windows can't get one remote connection working properly.

As for installing, Debian/Ubuntu can't get any easier.

        apt-get install <package>

And if you need the very latest nginx?

        wget <url>
        tar -xzvf <tar.gz file>
        cd <folder>
        ./configure
        make
        make install

Even better, you can script this with bash with little effort. (Complex scripting can be more difficult but that's not what we are doing here)

<comment><USER12> You're comparing apples to oranges. One is graphical while the other is text based. I've personally never had issues with RDP and bandwidth. If you have multiple connections open you can minimize the RDP window; the connection is maintained but the window is not refreshed so it doesn't use your connection.

</comment></comment></comment></comment></comment></comment><comment><USER13> By the same token, we should be amazed that most shops use Mac and Linux, even though Windows has tremendous market share. Or why we aren't using Java.

> Enterprise and startups aren't mutually exclusive – they're just different > stages in the evolution of software

I think that if you told most startups that 'Enterprise' was another stage, a future stage in the 'evolution of software', they'd hang themselves.

</comment><comment><USER14> The author asserts that Visual Studio is a much better development platform than everything else. I use IntelliJ, emacs, Unix cli, Perl, etc What am I missing? I'm sure Visual Studio is good but even if it's better, how much better is it?

<comment><USER15> Do you like IntelliJ?

If so, Visual Studio isn't as good, but is kind of comparable. It's better than Netbeans. Personally I prefer Eclipse, but I can see that others may prefer VS.

<comment><USER14> IntelliJ is great. They have a free version for people who want to try it.

<http://www.jetbrains.com/idea/index.html>

The same guys make Resharper for Visual Studio. I can't imagine that Visual Studio is better if the Java guys are making a plugin for it. I have heard that for C++, VS is hard to beat, but I haven't done that in a few years.

<comment><USER4> For VS 2003 I had to use ReSharper to make it bearable. For VS 2005 it made it better. For VS 2008 ReSharper didn't really add anything anymore, and VS 2010 has all the features of ReSharper and more.

VS has evolved quite a lot, and I don't acutely miss Eclipse anymore whenever I'm in VS.

</comment></comment></comment></comment><comment><USER16> there is a whole generation of developers who came out of college with the notion of Microsoft being evil.

also the trends setup by VC's like YCombinator, good college/university like MIT is, you can make cool products with open source ecosystem.

not sure how much you would remember, about 15 years ago it used to cost a large chunk of money to build scalable apps as 70% of the investment was sunk into datacenter acquisition.

another cool aspect is lot of new popular apps like posterous, started out as a single usable idea were implemented over a weekend and polished with multiple iterations.

licensing cost is still a big negative for those have discovered the power of open source technology, also the community is lot more evolved in sharing the expertise.

application frameworks like Ruby on Rails played a big role in getting the best practices like MVC Architecture, source code management, TDD/BDD, code generation, reuse in open source web frameworks

cloud computing infrastructure like amazon web services and linode VPS maks people experiment new projects at lot less cost.

Personally I have problems with many .Net developers who are "fish out of water", when it comes to living without the Visual Studio IDE. standards and features like XHTML, AJAX(prototype, jquery others ) came lot later in .Net programmers toolset until Internet Explorer was the leading in developer mindshare.

</comment><comment><USER17> I'm using .NET ... most of the tools are provided free and the full versions provided free by BizSpark, which I joined for free and now have a 3 year MSDN subscription that entitles me to a load of stuff.

It was only very recently that I stopped running <http://www.swfstats.com/> on SQL Server Express.

I think the real difference is it's just not front page news you're doing x with .NET. The web just likes to amplify and exxagerate certain 'accomplishments' ... doing your job in C#, Java, MySQL etc aren't on that list.

<comment><USER18> BizSpark isn't really free, is it? You have to pay full price once you fail to meet the eligibility requirements.

<comment><USER17> There's a $100 fee when you finish.

</comment></comment></comment><comment><USER19> Because like most enterprise software the people using it aren't the people buying it. When they have a choice they go elsewhere.

<comment><USER20> My real world experience with this is entirely different. Most .net devs are doing what they do because they have the best job prospects in that slice of the industry, especially in light of the overall skillset for the average .net coder is 90% .net, and 10% in the other languages learnt during thier degree.

I personally enjoy working in .net; the entire development process is very smooth and intergrated.

</comment></comment><comment><USER21> What sounds more attractive to a Hacker type looking to work on a startup?

"Come be an effective software engineer in today's new start up and use .NET to change the internet!"

or

"Laid back atmosphere, free pizza, Ruby and text mate. Let's get at it."

MS is a tool set - not technology. Hackers are very opinionated and want to do things their own way. In my experience, .NET, VB, Visual Studio (all while great _tools_ ) require you to do things _one way_ , _their way_. That just doesn't sit well.

Then of course there is cost, stigma, lock-in, etc. Start ups are the _anti- Microsoft_ , using it as a platform to build their technology, from a very _fundamental level_ , is dissonant.

It certainly is culture shock, and its not going to get any better for Microsoft in these markets. But they don't care, their business isn't designed for it. Microsoft doesn't do consumer products well. If you think about it, the only reason DOS got in front of everyone is because they were able to sell it to IBM.

<comment><USER22> > In my experience, .NET, VB, Visual Studio (all while great tools) require > you to do things one way, their way. That just doesn't sit well.

To be honest, that's not my experience. I've found that .NET gives you a lot of freedom, however things can be indeed easier if you do things the "recommended" way, but there's also an "if that's what you want, you can do it if you think you know what you're doing" mentality as well in the design of the framework. I mean, C# even has pointers which is quite uncommon in similar high-level languages, albeit well hidden so you only get to use them if you really want to.

Contrast that to Python's famous "there's only one way to do it" philosophy. Don't get me wrong, I think Python is really great stuff but I think it's unfair to say that .NET (as opposed to Ruby or Python) forces you to do things "one way, their way". If you want to do web development, you can choose between MVC and the (kind of) continuations of WebForms; imperative or functional, direct SQL, LINQ or the Entity Framework etc. - there are a lot of choices to be made.

</comment></comment><comment><USER23> _Visual Studio destroys [other environments] in any feature set-to-feature set comparison._

sounds an awful lot like

 _No wireless. Less space than a nomad. Lame_

Even for the nerdy, a long feature list is not what actually makes people want to use a tool. In the case of Emacs, it's the customizability. With Vim, it's the simplicity, speed and focus on its purpose. Other environments have their own advantages that don't fit neatly in to a feature list.

<comment><USER4> There are addons to make Visual Studio editing just like vim. Or Emacs if you prefer that.

<comment><USER10> And the Vim plugin is an absolute failure, and the development enviroment takes 30 seconds to startup, 30 seconds to connect to a TFS server over the Internet, and stutter every 20 seconds whenever you want to switch windows. oh, and let's not forget the 15 second build time for debugging.

Vim is here, now, the very second you need it, over an SSH connection, and far, far more customizable and with more useful plugins. The advantages of Visual Studio (namely, integration of features and great code completion) are lost when a framework fits in your head and you've automated most of your tools.

I say this as a person that spends 50% of his time on VS, the rest on Vim.

<comment><USER24> First, VS shouldn't take 20s to switch windows. I just did it and it happened instantly. And I have 60 open windows (not including tool windows).

Second, how is Vim more customizable than VS? I can't think of anything I can't do in VS. There's plenty I can't do in Vim.

Vim does load faster. Although single file load with VS isn't too bad, but certainly no Vim.

And don't use TFS... that's just bad mojo.

I say this as a person who spent 12 years of his life using Vi/Vim before touching VS for the first time.

<comment><USER10> Have you tried using Silverlight for a RIA app? Rendering a XAML file takes at least 5 seconds, and it's a process that's riddled with bugs and consumes at least 1 gig of memory. I'm sure the WinForms designer is much faster (I've never had any trouble with it in VS 2008), but the new toolkits with WPF and XAML seem to consume all the resources of my dual-core laptop with 3 gigs or RAM (a somewhat acceptable dev machine), the parser is horrendous and prone to causing unexpected exceptions, and is generally not as nice.

</comment></comment></comment></comment></comment><comment><USER25> I think a big difference is how we define small, e.g. Wikipedia tells me:

 _In the United States the Small Business Administration establishes small business size standards on an industry-by-industry basis, but generally specifies a small business as having fewer than 500 employees for manufacturing businesses and less than $7 million in annual receipts for most nonmanufacturing businesses._

When Microsoft makes something for small business, that's what they are imagining. For a boot strapped hacker working on a website, 500 people and $7 million is a long long way away...

</comment><comment><USER26> Why nit just know your place? Microsoft is fine (or at least was fine with) targeting massive enterprises and signing lucrative contracts with lots and lots of zeroes and lock-in. Why not adopt some unix philosophy into the ms ecosystem and just do one thing well.

I was willing to sympathesize with this article until the visual studio destroying everyone else feature set wise comment. Despite what you may think you are about the topic, you are just inviting a holy war.

As someone who has used visual studio, eclipse, and text mate regularly I would be hard pressed to say that visual studio destroys anything. I would prefer eclipse since it can do things like "open type" and "organize imports" natively. Things that come for free in the free and open source eclipse ide require you to buy the $80 resharper plugin for your $400 ide.

<comment><USER27> Everyone's going to have different favorite editors; nothing wrong with that. However, the _free_ version of Visual Studio 2010 has both the features you cited.

(and for what it's worth, I wasn't the one who downvoted your comment)

</comment></comment><comment><USER28> .NET FW is 1st class at tehnical level, but Microsoft platform around it is no good for a startup. You want to write mobile apps - Windows Mobile/Phone is a joke. Want cloud computing - Windows Azure is $100 per month for the simplest web site, no matter how many requests served. There is no also no way to play with the real thing for free.

Another problem is most MS internal developers still live in the 80s. You can hear "Real man write C++" all the time. Just browse the source code, written by MS employes, on Codeplex. They write C++ in C#. The APIs are out of this world - 25 or 50 lines of code to use a simple feature is no problem.

</comment><comment><USER29> I did some .NET development in college and after years of Python and PHP development, I finally started working on a Rails project about a month ago, and a couple of weeks ago I had to do some .NET development for a client. Obviously you can do anything in any of these environments, but I really did find .NET to be the most difficult to work in.

My issue is mostly around tools, not any of the languages themselves. In my ubuntu/rails environment i was up and running in 5 minutes with a text editor and a couple of sudo aptitude commands. With .NET i had to spend hours downloading and installing two different versions of the .NET framework, VS 2010, and SQL Server Management Studio. This was to say nothing of any external libraries. Now that i am up and running and my environment is setup its fine i suppose but frankly it took days just to be able to do hello world. With Rails I was there in 5 min, and it scaled with me. It was proportionally just as easy to get hello world going as something more complicated. The base bar to getting moving in .NET by comparison was several days - and if i wasn't being paid to do it, i never would have just for the sake of playing around.

</comment><comment><USER30> I only programmed .NET in the days of 2.0, so my problems with it come from an older less capable framework. Nonetheless, when your language of choice requires you to distinguish between:

\- IComparable

\- IComparable(Of T)

\- IEquatable(Of T)

\- IStructuralEquatable

\- IStructuralComparable

\- IEqualityComparer

\- IEqualityComparer(Of T)

\- IComparer(Of T)

\- overriding Object.Equals

\- overriding operators <,>, <=, >=, =, <>

...it's time to find a new language.

edit: Just imagine you encounter a new collection BozBag(Of T) which has to test your objects for equality. Without looking at documentation could you as a coder possibly know if BozBag uses x.Equals(y), x = y, x.CompareTo(y) = 0? Heck it could even use x.Equals(DirectCast(y,Object)) or x.CompareTo(DirectCast(y,Object)). The only way to really know is to dig through documentation.

<comment><USER31> Saying that you need to understand and differentiate between all of these is disingenuous.

\- The "Structural*" types are new in .Net 4.0, you never had to understand them before and you probably don't need to even know they exist now.

\- Many of these listed are just generic vs non-generic. The generic ones subclass the non-generic ones, so contraviance eliminates the need to really understand the distinction upfront.

\- Compare means Compare(a,b):int which returns -1, 0, 1.

\- Equals means Equals(a,b):bool

\- If it ends in "er" it is a functor which operates on two free objects instead of "able" which means one subject of comparison is "this".

\- Overriding individual operators gives you more flexibility than Compare(a,b):int because you can use specific algoritms for specific comparisons.

Maybe it's time to find a new arbitrary reason to hate .NET?

<comment><USER30> >\- The "Structural*" types are new in .Net 4.0, you never had to understand them before and you probably don't need to even know they exist now.

You're right, I scooped those off MSDN and never use them myself. All the others, however, have made numerous appearances in my code. I think that the preponderance of comparisons is a language smell-- it's not close to my only problem with .NET development but I think it captures the essential headache- inducing inelegance of C#/VB programming. That language-blob has little regularity but much accretion. There are rarely sane defaults nor any overarching design for your mind to latch onto. After time spent with saner languages (Python, Haskell, Ruby, OCaml, etc...) coding in .NET feels terrible.

<comment><USER31> Java also has Comparer and Comparator in both generic and non-generic flavors. Java lacks Equatable, which is a problem. Haskell, for example, has both Eq and Ord. It is frequently possible and convenient to be able to implement Eq in terms of Ord and part of Ord in terms of Eq, but these are orthogonal concepts.

As someone who has done _A LOT_ of professional C# development: I've found that with only a few exceptions, the .NET base class libraries are very well designed with entirely reasonable defaults. I use Python primarily now and, in general, the core .NET libraries seem to be better designed than most of the older Python libraries (many of which are getting properly cleaned up in Python 3).

Every environment has its cruft.

</comment></comment></comment></comment><comment><USER32> You dont have to use webforms, and using ASP.NET can be quite pleasurable if you dont use the "asp" controls and postbacks.

HOWEVER, the second that Sharepoint enters the equation, I turn, run, and dont look back. What a horrendous kludgefest that is...

<comment><USER11> How do you use ASP.Net without webforms? I ask because I've only had a one course introduction to ASP.Net Webforms in school.

<comment><USER33> <http://www.asp.net/mvc>

</comment></comment></comment><comment><USER34> Maybe the author should consider this possibility:

Startups don't use it, because: \- there may be other technologies that are better for the job \- startups rarely care about Microsoft's heavy marketing which alone can convince a lot of managers to use a technology just because it's from Microsoft

And one of the worst things is that it's a Windows technology, say what you will, but if you want .NET you need Windows, and pay a zillion $-es for license. Yes I know there is Mono, it's very close, but no cigar, it's like wine, it lags.

But in the end I want to ask a question too: What could .NET bring to startups that other languages can't?</comment>


Ask HN: Feedback on a project - <AUTHOR>

I've made a site for localized twitter trends: http://www.happn.in.
Its sole function right now is to group Twitter trends by city, display these on a page, and tweet them out to followers a few times per day.
HN, where would you go with this? Looking at trend histories is tempting, but I just want to tell people what's going on right now.
Writing some code to classify tweets into [music, arts, politics, etc.] also seems like a possibility...
Any other suggestions? Does the world even need another Twitter trending service? <comment><USER2> That is an interesting idea. I like to see what's going on nearby. I think you might want to geolocate based on the IP and filter only the stuff that is nearby me. ~90% of the people are only interested in the stuff that is happening nearby. For instance I only looked at the San Diego and Los Angeles stuff. Of course you should be able to browse all the items if you really wanted to. (A New Yorker who is visiting LA for instance might want to see NY stuff.)

Another suggestion would be to offer up more than 5 items if you click on the subsection heading.

The world does not NEED another twitter trending service but if you can do it better than the others and differentiate yourself enough you might be successful.

</comment><comment><USER3> Like weaksauce suggested, some sort of auto-detection (although build an override too) would be a good start. A simple addition would be to make links clickable.

You could look into overlaying tweets onto a Google/Live Earth map (although this would only be useful for those tweeted from a phone with geolocational data).

<comment><USER4> Off-topic, but twittervision.com</comment></comment>


Is Bill Gates Really Batman? - <AUTHOR> http://www.triplepundit.com/2012/01/bill-gates-really-batman/ So what exactly has Bill gates done to deserve to be considered such a hero besides making a ton of money? <comment><USER2> hehe. interesting points.

but remember that he would be probably giving out nothing if it wasn't already lost to taxes already.

so, the sum have to account for the things that would have been done with the tax money (and remember, for every $2 of tax, $1 get's lost or pay for overhead. in multimillion non profits, it's almost $9 out of $10)

Also, he need to win the money in the first place. For every student that want's to buy a linux laptop, they pocket at least $100. so also account that for every textbook he donates, two were taken away from a student previously.

ok, those are a couple starting points... you can go on from here.</comment>


How to host and manage static sites (of unlimited size) for free on Github - <AUTHOR> https://github.com/maxogden/gh-pages-template

<comment><USER2> I had a problem with Github user pages for the past few months: It stopped building.

At first I was more than happy that for every commits, I can see the changes immediately, but after few days, it just keep showing the old build. I even started a fresh new accounts and setup a new user page, same thing happened. I tried many things to make it work, adding/removing CNAME, changing the page content, even waiting for few days, no luck. Tried to contact the Github team (via Twitter and the Contact Us page), no respond.

Now I am using my shared VPS to host a static site, waiting for some good news about build reliability, until then I wouldn't recommend using Github user pages.

Oh and by the way, if you set a CNAME, you wouldn't be able to access your project pages without adding it as a submodule into your user page.

<comment><USER3> I put up a static page a couple of weeks ago with no issue. Granted, I'm not using Jekyll and just generating the static files on my own locally before committing / pushing.

<comment><USER2> I'm using Pelican as a static blog engine, had no issue at first, this happened after the number of commit grow.

</comment></comment></comment><comment><USER4> I wonder if people start abusing this if Github were to put any restrictions on it somehow. For quick one off single page things sure why not, but if people start trying to host huge websites on Github? I'd be curious as to their response.

<comment><USER5> Yeah, this is ripe for abuse by pornographers. :(

<comment><USER4> Really? Care to expand? That just surprises me!

<comment><USER6> I'd imagine the bandwidth for a porn site is huge, imagine having all that bandwidth dealt with by someone else for free! plus the porn industry tends to get in on new technologies early so Id be surprised if there isn't some somewhere.

Unrelated to porn this sort of thing could be great in general as all the content is searchable it would be a goldmine for information on how to use a function or do some specific action. I already use git as a codex of sorts!

</comment></comment></comment></comment><comment><USER7> Great for hosting documentation, blogs, brochure sites or simple static clients: push your API code on master and other branches and have your static client to consume from the API on the gh-pages branch.

Be careful though, __if you push something on gh-pages it will be public, even if your repo is private __.

From what the guys at Github told me, they don't have to restrict their users as long as you don't commit obvious abuses. Either very large files or gigantic amount of files, which will both create issues with Git. In short, "don't be a dick".

</comment><comment><USER8> Github pages is a fantastic service. I use it as an automatic archive for a daily mailing list: <https://github.com/simon-weber/the-listserve-archive>.

Basically, Github is my free host, database and api.

</comment><comment><USER9> OT, but I'd love to know what HN think about this:

The license part of the README.md says "The content in this repo is BSD licensed".

AFAIK licensing requires:

\- A copyright line with the year (or years) and the name of the copyright holder.

\- IIRC a way to contact the copyright holder is required (email, URL, etc), but I may be wrong and it's just optional.

\- A copy of the license grant/notice is required, ie. the "boilerplate notice" form Apache license that includes a link to the full license text.

In this case, does the "The content in this repo is BSD licensed" sentence have any kind of effect?

EDIT: ate a word, formatting

<comment><USER10> (IANAL, most familiar with UK rules)

Generally a author has copyright over their works without having to explicitly says so. Saying "Copyright (c) YYYY AUTHOR NAME" is just a way of asserting it to remove potential confusion or ambiguity.

With no licensing, there is no right to use a copyright work (except fair use). BSD licensing a work is _granting_ permission is a set of circumstances, not revoking permission. Thus if a license is not correctly applied the work cannot be used, rather than the inverse.

As for "The content in this repo is BSD licensed" - the usual licensing wording is again a convention designed to be as clear as possible, but the wording applied there probably counts as it pretty clearly intends to give permission. The "probably" is why people ought to stick to known and understood conventions.

</comment></comment><comment><USER11> ...if you give something for free and don't set limits, people will find ways to abuse it ...and then you'll have limits for everyone ... _I ask all web developers out there to not use Github pages for clients' websites_ , it's not like you don't have room in the budget for almost-free webhosting for static websites, it's probably something like 0.(...)1% of website maintenance and dev costs and there already are free blog hosting services. use github for _your_ website/blog, _you family's_ , _your pet's_ , but _not for your clients'_ , please...

<comment><USER12> A lot of clients are actually willing to pay for you to host their site, just as long as they don't have to do anything technical. We're talking £350 for a year in a lot of cases and the site could simply be an addon domain on a package with a few sites on it. This also includes a walk through of setting up emails on Outlook, iPhone or what have you.

They just don't care because you end up doing something that takes you 5 minutes and little to no energy which would be next to impossible for them.

Since the margins are so high, you also have freedom to make nice discounts without a loss.

</comment></comment><comment><USER13> I miss Geocities

<comment><USER14> You know what? Me too. I miss Geocities and I never realized until just now.

That was a great internet. The people's internet. I was 13 years old but I was allowed to make a website for free, with no help or direction from parents or teachers or anyone, with barely anything to learn.

And when I was done it was _there._ It was a thing I made on the internet and I could show anyone. And I did, and it was probably embarrassingly bad, but that's not the point.

I think more than anything in my career, services like Geocities inspired me.

 _See the internet? You can make it. You can do this stuff. It's not that hard._

Nobody else in my life told me that. Nobody explained to me that creating things on a computer _wasn't magic_ , and if I wasn't enticed with such an easy website creator I may have never known.

What do I give my kids? What do I give my little cousins, right now, at the age of 10, that even comes close?

\---

Looking around there seem to be a few, but they're all so template-centric that I wonder if I'd feel the same way if I had them back then.

<comment><USER15> I wish I could upvote this comment more than once.

I remember getting on Geocities in 1996 and finding a burgeoning community, full of randomness and fun, all learning as we went along about how build websites. I remember mine was in the "Bourbon Street" "neighbourhood".

I had a lot of fun that year, messing about on IRC, learning HTML, building (ugly :-) websites, helping others do the same. Can't believe I sound nostalgic about that place.

I think I'll set up my daughter (nearly 9, already has her own domain) with a GitHub account, and set up Pages so she can play with HTML, CSS and stuff.

<comment><USER13> Same here. I remember in '97 my grandma bought me a Geocities "plus" (or whatever it was called) account so I could have a geocities.com/~username vanity address. All my real life nerd friends were so jealous of me. :-)

Having free home pages on Geocities did a lot for my career. What will my son gain from whatever "social" web site is around when he starts using a computer (and yeah he also already has his own domain name)?

</comment></comment></comment></comment><comment><USER16> Seems like a good place to link to "Poll: What's your favorite static site generator?"[1] submitted a few days ago. The most interesting notion to take away is that, for all the buzz surrounding static site generators like Jekyll and Pelican, you can actually accomplish the same goal using absolutely any backend you're comfortable with. As long as your output doesn't contain anything dynamic, you can even use frameworks like Django or Rails then pair this with a spider (e.g. wget) to pull all the dynamically-_generated_ output into a static snapshot that you then upload to GitHub.

[1] <http://news.ycombinator.com/item?id=4857473>

</comment><comment><USER17> _What it isn't: a dynamic host -- so it can't do PHP/Rails/Node etc._

Seems like a good opportunity for sever-less folks like WebScript.io or Firebase to jump in and help.

</comment><comment><USER18> Is the ability to use custom domains free now? In the past I thought you had to be under one of the paid github plans.

Oddly enough, I don't see any mention of this in the github article explaining how to set up a custom domain: [https://help.github.com/articles/setting-up-a- custom-domain-...](https://help.github.com/articles/setting-up-a-custom- domain-with-pages)

<comment><USER19> In the root of your repo on the gh-pages branch:

echo example.com > CNAME

Then point it (if apex) at 188.8.131.52.

</comment></comment><comment><USER20> You can also create a static file blog with Jekyll <https://github.com/mojombo/jekyll>.

Pretty awesome and simple.

</comment><comment><USER21> Does one have to make the _yourusername_.github.com repo first for this to work? My understanding is that the Pages feature is only activated by doing this.</comment>


How to be a genius (2006) - <AUTHOR> http://www.newscientist.com/article/mg19125691.300

<comment><USER2> The other side of "putting in the time" is finding something you like doing in the first place. It makes the journey all the more interesting.</comment>


Ask HN: (Backend) coders, did you learn web design? If yes, how? - <AUTHOR>

I can work with backends but when doing projects solo, the site design becomes very important and I suck at it. If you could list some resources you started with, it'd be very helpful. <comment><USER2> I think there's an inherent tension in frontend web programming, particularly when you're the sole operator in charge of UX, visual design and implementation.

The part of you responsible for the UX and visual design wants to design nuanced flows and pretty pages. The part of you responsible for implementing wants designs that will be pragmatic (or easy) to implement.

My own personal exploration of this stuff began in late 2009, when I got into web programming again after a nearly 10-year hiatus.

What has helped me is to study design and implementation separately. The more knowledge I have of the modern frontend ecosystem, the more I expand the realm of "things that are pragmatic to implement". And the more knowledge I have of how design works, the more flexibility I develop in terms of "acceptable UX and visual design".

Put another way: if you know what is easy to implement, you can combine that with a study of design to combine those building blocks into something that looks good and works well.

Design resources:

The Non-Designer's Design Book by Robin Williams

\-- An excellent book that lays out clearly and concisely principles that will make your designs work. Perfect for the analytically-minded.

Thinking With Type by Ellen Lupton

\-- The web is still largely a written medium. Getting the typography right is a huge win. And this book is great.

Implementation resources:

* Head First HTML with CSS & XHTML by Freeman et. al.

* CSS Mastery: Advanced Web Standards_ by Budd et. al.

Helpful:

* CSS frameworks like Blueprint, Bootstrap, Compass

* Using grids

* SCSS/CASS/LESS

Also, Smashing Magazine (web) is very good.

To build implementation skills, it is helpful to take a screenshot of a site that you like and then implement it. To build design skills, it is helpful to sketch layouts that you find aesthetic and then build them out using lorem ipsum text.

You'll get there. It gets easier. And as someone told me when I complained about the breadth of stuff one needs to know: web development isn't going away anytime soon, you have plenty of time.

</comment><comment><USER3> This is a little bit beside your question, but since it's something I've noticed before: I think the best way to look at it is not, "I'm a back-end coder who wants to learn front-end design." The more honest truth is, "I'm a beginning design student." Trying to tie it directly into your back-end knowledge will probably not produce optimal results. Design is a different discipline, so if you approach it with the wrong preconceptions, the impedance mismatch will make it hard for you to get better at it.

</comment><comment><USER4> Here is my road from blank page to final product:

1\. Start with pen and paper. Thinking a lot about usability draw everything there. You could use balsamiq.com & similar, but for me paper & pen works the best in this phase.

2\. Look for design inspiration at dribbble.com & similar

3\. Look for colors inspiration at colourlovers.com, kuler.adobe.com

4\. Create PSD

5\. Create HTML+CSS

6\. Implement

That's it. At least for me it works very well.

<comment><USER5> I second this process! The pen and paper get the creative juices flowing quickly.. I would also add that I found Smashing Magazine a great resource.

</comment></comment><comment><USER6> I started off with a learn html in a couple of hours type book. Eventually I went on to <http://w3schools.com/>

To really become proficient with front-ends you need inspiration (for designs, ways of doing things).

There are many aspects involved in UI design, including but not all - psychological, preference, design theory, limitations, layout, typography, efficiency.

If you see yourself doing it 'part time' - learn html/css/js/jquery scripting and borrow designs and figure out how they work and how these patterns can work for you.

I have a firm belief you do get 2 types of designers - those who design for themselves and those who design for others.

Don't be too hard on yourself, it's really a full time job to get it right most of the time.

And here's a freebie: plan before you do - I personally like scratching on the old notepad.

<comment><AUTHOR> Thank you for the tips.

I don't have much of a problem with HTML4, but when given a blank page and asked to design something pleasing, I have absolutely no idea where to begin. Most of my colour combinations are awful. I am not sure about page utilisation etc.

I'm learning CSS and jQuery whenever I find time.

<comment><USER7> Pick a grid framework you like. I recommend either using the grid framework in Bootstrap[1] or Skeleton[2]. Skeleton I prefer because it has sensible typography from the start, and slightly more padding than you usually find in grid frameworks. These will help you control spacing and layout pretty easily.

As for color, you can find a palette that you like on colourlovers[3], then just work by varying what colors you want to use and when.

[1] - <http://twitter.github.com/bootstrap/> [2] - <http://getskeleton.com> [3] - <http://colourlovers.com>

</comment></comment></comment><comment><USER8> Every time design questions come up, design is made out to be some kind of mythical force people ether have or don't. Well that is not the case, design is a discipline like any other and can be thought to anyone willing, just like maths. The mythical force people see as design is what's called art, and is a highly subjective process based on feelings and emotioms, where as design is a logical progression from raw data to workable interface.

</comment><comment><USER9> I'm not a good designer but i've been improving for years mostly by putting in my hours. Aside from learning some basic photoshop skills, the best piece of advice I can give you is to read and re-read this article: [http://flyosity.com/tutorial/crafting-subtle-realistic- user-...](http://flyosity.com/tutorial/crafting-subtle-realistic-user- interfaces.php)

Note the word subtle. That's the key.

</comment><comment><USER10> Bootstrap from twitter is a good resource for getting a minimalist but still sexy looking frontend going quickly.

I also browsed ThemeForest, searched the "Admin" themes, and then wrote web projects using them. I have found the code quality of all of the themes I have purchase to be very high - all of the components were modular, and I've been able to put high quality frontend stuff together with no design skills :)

<comment><AUTHOR> Out of my frustration in writing HTML, I took a look at Bootstrap and some sites that were built using it and they looked very professional.

But I'm confused if I should learn to do webdesign by hand before using readymade frontend packages.

</comment></comment><comment><USER11> Check out Bootstrap open source project from Twitter on Github. It can give you polished look quick. I supposed Bootstrap is meant for backed coders.

</comment><comment><USER12> xscope is great, definitely try it out

<http://iconfactory.com/software/xscope>

<http://chengyinliu.com/whatfont.html>

<https://github.com/thoughtbot/bourbon>

</comment><comment><USER13> Another vote for Bootstrap - I use it on my site and it's fantastic and easy to implement.</comment>


Jeff Bezos could become world's first trillionaire - <AUTHOR> https://www.usatoday.com/story/tech/2020/05/14/jeff-bezos-worlds-first-trillionaire-sparks-heated-debate/5189161002/ <comment><USER2> We'll see if the people actually get sick and tired of seeing headlines like this while being asked by the same billionaires to donate so families who can barely make rent can eat while free school lunches are canceled.

</comment><comment><USER3> Is there so little to report that taking the average growth of his wealth for the last 5 years and extrapolating for the next 5 is worthy news? This is an absolutely worthless prediction. How can this be journalism?

</comment><comment><USER4> Some company makes an estimation as trivial (and speculative) as what anyone could produce an Excel?

This is not news. This is clickbait advertising.

</comment><comment><USER5> `The company said their projection is based on taking the average percentage of yearly growth over the past five years and applying it to future years.`

Past results are not an indicator of future performance.

</comment><comment><USER6> First publicly known trillionaire*

There is a lot of money out there not easily tracked. There are speculations over some shadier character's net worth, probably most notable is Putin.

</comment><comment><USER7> *While paying zero tax in the country that made that possible.

<comment><USER8> Are you saying that when Bezos sells Amazon stock he's not paying capital gains tax?

<comment><USER9> That wouldn't surprise me. There are probably entire companies working on nothing else but to reduce his taxes.

<comment><USER10> The tax rate is also low enough that if he does pay, it's not much. 15% total instead of the 30-40‰ I currently pay.

<comment><USER8> A nitpick: the long term capital gains tax for the top bracket is 20%, not 15% [1]. My guess is that Jeff Bezos is in the top bracket.

[1] [https://en.wikipedia.org/wiki/Capital_gains_tax_in_the_Unite...](https://en.wikipedia.org/wiki/Capital_gains_tax_in_the_United_States#Current_law)

<comment><USER10> Oooo neato I never knew there was a tiering of rates like this-- probably because I haven't had a reason to find out XD thanks for the info

</comment></comment></comment></comment></comment></comment><comment><USER11> Learn to code, USA Today!

</comment><comment><USER12> Well so could I

<comment><USER13> We're talking probabilities here. (Or you are one already, in Zimbabwean currency.)</comment></comment>


Malloc envy - <AUTHOR> https://engineering.vena.io/2016/04/04/malloc-envy/ <comment><USER2> > It's also important not to overstate the duration of GC pauses. Applications > don't need to stop for the entire duration of a garbage collection cycle: > they can continue to run and mutate objects (and even allocate objects), so > long as they coordinate with the GC.

I'm not much of a Java user, nor do I use GC for any performance-critical code, but I write code that interacts over the network with quite a few Java systems. These systems have all kinds of performance problems, a lot of which involve GC pauses.

Some of those systems come from vendors who have very competent teams and invest heavily in their systems, and some have tried fancy, expensive JVMs with supposedly better real-time performance and have failed to get them to work.

So I'd offer a statement in the other direction: it's important not to overstate the ease of avoiding GC performance gotchas. Maybe it can be done, but that doesn't mean that you're going to be able to do it, especially if you don't design all parts of your application from the beginning to operate within the constraints of real-time GC implementations.

<comment><USER3> The JVM has a lot of other reasons to pause [1]. A big problem with using the JVM as an example is that it's an enormously complex architecture that wasn't really designed for the kind of workloads it is subjected to these days. For example, the complexities involved in having a JIT compiler in a multi- threaded environment that wasn't designed from the ground up for that purpose can be pretty scary (e.g. the method deoptimization issue in the video). The effort that has gone into the various JVM implementations both impresses and scares me.

[1] [https://www.youtube.com/watch?v=Y39kllzX1P8](https://www.youtube.com/watch?v=Y39kllzX1P8)

<comment><USER4> In what sense was the JVM not designed to be a JIT compiler in a multi- threaded environment?

<comment><USER5> Like (somewhat ironically) Javascript, Java's origins can be very easy to forget, and also like Javascript, both are surprisingly humble. Javascript was banged together in a week, and Java was intended to be a language for developing constrained set-top box UIs in the 1990s. While that does not render them intrinsically unsuitable after decades of development for the sort of tasks that they are put to today, the early days of a language still inevitably color it forever when backwards compatibility is a big concern.

<comment><USER6> To distill your contribution to its essence:

 _Parent: what 's wrong with the JVM as a multithreaded-JIT?

You: Java is similar to Javascript. Javascript was terribly designed in the 90's. Therefore Java sucks . QED._

You should try your hand at politics! Don't answer the question (Java), instead, segue into the more comfortable topic/what _you_ want to talk about (Javascript)

<comment><USER7> Um, jerf gave a reason why Java's history affects it here and noted how it's similar to Javascript in that regard on the side; not the other way around. The JS comparison was not part of their argument.

<comment><USER6> But that has _nothing_ to do with the question he is responding to; regarding Java's suitability as a multithreaded JIT

</comment></comment></comment></comment></comment></comment></comment><comment><USER8> I've heard these arguments many times before, about how in theory GC'd languages can have less memory allocation/deallocation overhead. This theoretical benefit never materializes, though. This is because in a language with garbage collection the programmer barely thinks about memory at all which results in millions of tiny allocations happening all over the place and that wrecks performance. In contrast to languages with manual memory management where programmers use strategies that minimize the headache (memory leaks and doubly-freed data) of manual memory management which results in there being vastly fewer memory operations.

Where in a dynamic language people are tempted to use write things like `people.pick('name').capitalize().sort()`, where containers of objects are created at every stage of the pipeline just to be discarded moments later. In C you wouldn't write code like that. Or if you do, you simply allocate a single block of memory beforehand that's large enough for the entire operation and you reuse that memory block at every stage of the pipeline. In C more memory efficient code is less work to write and easier to reason about.

So it really shouldn't be a surprise that in practice GC'd languages like Java are dogs in terms of performance, nor should we expect this to change no matter how clever the garbage collectors get. The "sufficiently intelligent garbage collector" is a creature just as mystical as the "sufficiently intelligent compiler".

<comment><USER9> This is nonsense. Games using Unity think about it all the time and that's using C# and a GC runtime. (Here's a dirty little secret: C++ games use object pools too and for the same reason! You can't afford to take the malloc/free overhead in the middle of rendering a frame, any more than you can afford a GC pause!)

Again looking at C# (or Swift's Lazy collections, or Java streams) your example isn't quite correct. You can absolutely get single-pass lazy evaluation of the elements, or at the very least avoid any temporary intermediates.

The .NET runtime has various GCs, some of which are concurrent GCs that can do thread-local pauses without pausing the entire process, as well as doing extremely short pauses (a few ms) but otherwise running concurrently with other threads doing allocations. The GC even does compaction, avoiding the memory fragmentation problem that has driven many a C programmer crazy. (There are other approaches like V8's JS GC.)

The idea that GC has to be a dog is nonsense. It has the benefit that allocation is just adding sizeof(object) to a pointer, making allocation trivial. It has the runtime overhead of occasionally needing to pause things for memory safety reasons, depending on the specific implementation. It also has a higher high-water mark for memory usage. It has the human overhead of reasoning about living roots and avoiding unnecessary object churn (though that is true of any system).

Reference counting has runtime overhead of incrementing/decrementing reference counts, and human overhead of manually breaking retain cycles and remembering to properly increment/decrement the counts (unless using things like ARC which insert the calls automatically).

malloc/free has runtime overhead to manage slabs and free lists, plus fragmentation problems under some workloads. It has a massive human overhead of making the programmer remember to track and free the allocated memory perfectly or risk leaking or corrupting memory, potentially leading to remote code execution in the worst case.

These are all tradeoffs with costs and benefits.

<comment><USER10> My experience with XNA (a C# based gaming environment) was that allocating memory and incurring GC was death. So you bent heaven and earth to avoid making garbage.

I haven't used Unity. It's probably better. (XNA was essentially abandonware a couple years after Microsoft hatched it -- a typical myopic lifecycle and a good reason why you can't trust MS with your platforms unless they have a _really_ strong money story behind them).

</comment></comment></comment><comment><USER11> Currently I work as engineer in video games, and I would like to say that next step is just to write software completely without malloc+free and GC : you just allocate virtual pages directly from OS, create your own pool allocators in them, and that it. When you need to "free" stuff you just wipe whole virtual page, O(1) free, faster then anything you could imagine. We have only three special cases : string operations (usually implemented with special string pool), heap (malloc + free) for libraries that cannot live without it, and everything else on stack.

That said, I honestly don't understand why everyone only talks about GC and malloc+free abstractions, because they simply do not materialize in physical world at all (even if malloc needs a new page, it will call kernel for it), cpu/kernel do not have such mechanisms, so this is only abstract limitation in developers heads. So why not just talk (if we actually end-up in situation when we need to talk about memory, 'cause usually it's just work) and measure about what's actually real?

<comment><USER12> Video games end up being a special case where you tend to have somewhat discrete checkpoints and can dump large parts of RAM via pages.

Still pooling is something that everyone should be taught and seems like very few are.

<comment><USER13> I'm not sure it's that special. At least the arena allocator approach. It's a great solution servers too. If the connections are short-lived, you can just give a few pages to each one and unmap them at disconnect.

</comment></comment></comment><comment><USER14> > An array in C++ has none of these things. However, consider that if the > array is ever to be freed by free, then its size must be recorded anyway. > That leaves 8 bytes of overhead, which is likely comparable to the overhead > caused by malloc's fragmentation.

Actually, no, it does not need to explicitly record the size of the allocation. Some implementations of malloc do this, using what are called "headers". But more modern allocators tend to use techniques which avoid this. They basically follow the pattern:

1\. Maintain a list of slabs, where each slab contains objects of a particular size (say, 4, 8, 16, 32, etc, but not necessarily always doubling by 2).

2\. You ensure that the slabs are in contiguous regions of virtual memory. The start is always on a page boundary.

3\. For each page, you record its meta-information in either a giant array (for small address spaces), or a radix tree (for large address spaces).

4\. Upon a free, you can just figure out what page an object lies in, then look up where its meta-information is. Then you have all of the information you need to free an object of a particular size. This function from an old project of mine shows all three techniques (headers, radix tree, giant array, also called a BIg Bag Of Pages): [https://github.com/scotts/streamflow/blob/master/streamflow....](https://github.com/scotts/streamflow/blob/master/streamflow.c#L1386)

Something else the author did not mention is that when it comes to performance tuning a GCed application, you have another variable: heap size. If the heap size is too small, you will GC too often. If the heap size is too large, your pauses when you do GC may be too large. It may require tuning to find that sweet spot.

Also, this came up in a previous thread ([https://news.ycombinator.com/item?id=11058911](https://news.ycombinator.com/item?id=11058911)), but the routines the author outlined for object allocation are quite similar to the ones used in modern implementations of malloc.

<comment><USER7> (this only works if destructors/finalizers don't exist). You still need runtime type information if you want to be able to properly clean up a thing. E.g. what would happen if I put a `std::vector` on the GC heap?

<comment><USER14> It works just fine with destructors and finalizers, as this is the underlying implementation of explicit memory allocation. One can build a true type-aware object system on top of it. This is how C++ does it.

Please note that I am talking about techniques for explicit memory management, not garbage collection.

<comment><USER7> Oh, you were talking about a non-GC situation. Right.

</comment></comment></comment></comment><comment><USER15> Something this doesn't mention is that for a given program written in both Java and say C++, the C++ version will have to perform much fewer allocations than the Java one. Escape analysis can help with this but afaik it's not even a full replacement for stack allocation, not to mention the other scenarios where C++ doesn't allocate.

On the other side, this also doesn't bring up that any sort of concurrent data structure is much easier to write when using a GC, and the GC removes the need for expensive memory tracking. It doesn't necessarily make things faster, and libraries like Crossbeam and epoch management in general make things easier, but Crossbeam isn't fully featured, is Rust only, and still suffers from strange bugs.

A worthwhile side note is that when manually managing memory, non-malloc allocators can often be used if really needed that have far higher performance than both malloc/free and a GC.

<comment><USER16> Instead of Java, a comparison should use a language with value types (structs): C#, D, etc

<comment><USER17> I like the C#/F# have value types, but they have the downside of not being able to do away with the default constructor for the type, meaning it's harder and less efficient to control type invariants (would have to guard validity in methods repeatedly instead of being able to gaurantee valid construction). For types for which a default/"0" value is a legal value they are good of course.

<comment><USER16> I don't understand. What is the problem with default constructors?

<comment><USER17> The problem with the default constructors is just that for value types, you can't not have one. For plenty of kinds of things, there's no sensible default value that would make any sense, but your type must admit such a value anyway, there is no choice.

Which means when you have a value of the type, you can't assume it's in a valid state. You have to put checking code somewhere, either in each method of the type, or in functions that receive the type as a parameter, in clients that create objects of the type, etc.

</comment></comment></comment></comment></comment><comment><USER18> This really is an apples to oranges comparison.

In C++, you have to know the difference between stack allocations and heap allocations.

If you aren't dynamically allocating anything; malloc and free performance has no bearing. As far as I know, Java has no reliable way to create an object purely on the stack (and it probably shouldn't.

And even if you are dynamically allocating a new object in C++, if it has non- pointer children, it allocates that memory too in the same allocation call.

It is true that a lot of allocations will slow down C++ a ton; but a lot of allocations can be avoided in C++ whereas in Java you don't get that fine of control.

Even then; there is nothing about the malloc+free contract that prohibits you from having an implementation that does some of the things the author talks about. You can make a version of free that marks memory locations to be freed at the nth call of free.

I'm curious on the source for this statement:

> Java's collector can free an unlimited number of objects in time independent > of the number of objects freed.

That seems like it can't possibly be true in the generic case.

<comment><USER19> It's true, because the time to free objects is not related to the number of objects freed- it IS dependent on the number of objects that AREN'T freed. The GC time (in a very general sense) is the amount of time it takes to traverse the live object graph.

<comment><USER18> Isn't that true only for objects in the 'new' pool? Or does it actually compact the old pool every gc?

<comment><USER19> I'm not sure I see the connection you're trying to make. The specifics of old pool vs new pool (generation is the preferred term) are dependent on the GC config, but in no case can you find memory that can be freed by traversing a "dead objects" graph. Liveness is what drives the relationship between size and computation time. Big O notation stuff.

<comment><USER18> So my understanding of the new generation is that it's essentially a giant chunk of continuous memory and as you create new objects, you are just adding to the end of it. For whatever reason a GC event happens, and now you can traverse the live graph, and anything alive in the new generation gets copied to the old generation partition of memory. And now you just reset the counter for the new object pool, and voila, you've deleted a whole bunch of young objects just by not copying them.

But once it's in the old generation, you run right into the same issue with fragmentation and having to keep track of where deleted objects are so you can reuse that space. If the idea is that you just keep doing memcopies for all the live objects to reuse the space and avoid looking at dead objects, I'd think that that is it's own performance issue?

</comment></comment></comment></comment></comment><comment><USER20> If anything, Rust shows that you can have reliable "manual" memory management without the need for a GC. The best of both worlds.

While I don't buy the GC performance argument, it's ok to use it, because most of the time it doesn't matter. Sure it can be "almost as good as" manually managing memory, but that's about as hard to achieve as manually managing your memory. The point of GC is that it relieves the programmer of caring about managing memory, and as such it's only really useful where the system has sufficient resources that the fact that a GC is running doesn't matter. For the vast majority of workloads on modern hardware this is true.

At the other end of the scale, in real high-performance embedded systems, even malloc+free is too slow, and memory fragmentation is too much of a problem for things with expected uptimes measured in years. GC is a complete non-starter here. Instead these systems use pools of fixed-size buffers than can be O(1) allocated and freed, and never fragment. You can use MRU allocation of buffers from these pools to keep the dcache warm, and you can make your memory-using operations queue until they can reserve the memory they're going to use up front so that your system can run flat out using all the memory it can without ever crashing from OOM. Both malloc+free and GC (especially GC) can only dream of those characteristics.

</comment><comment><USER13> I feel like this article goes in the typical trap - you either do fully manual malloc/free, or stop-the-world mark&sweep. But that's like extremes on the spectrum. What about arena allocators (in dynamic content for example per- scene and per-frame). What about selective refcounting. What about mixing systems in various heaps. What about lightweight processes with own, well adjusted local heap size. There are so many options available in real world. GC is not Java, and Java also works against a good GC with the lack of value types.

<comment><USER21> I'm the author of the article, and I agree 100% with you: there are definitely application-specific memory management schemes that beat both malloc and automatic GC. In fact, I'm working on one right now: it's a way of storing a huge balanced tree data structure in arrays to save space.

</comment></comment><comment><USER22> This whole post is nonsense, but there's one point in particular I think that GC advocates don't understand about managing memory. He writes, "Consider: you need to hand out chunks of memory of any size, one at a time, with no advance warning of usage patterns; and then you need to be able to free arbitrary chunks at arbitrary times."

This is entirely wrong. Sure this is true if you're writing a general purpose programming language, but if you're writing an app or a game or a tool, you know the usage patterns because you are building them. You don't need to free things at "arbitrary" times, you free chunks at times when it is appropriate for your problem. You know more about your memory allocation patterns than any general purpose GC could ever know, and so you can write code to fit those better.

In a GC language, often you don't care about where and when the memory comes from, but sometimes you do, and when you do, you're stuck.

<comment><USER16> You can put a manual allocator on top of a runtime GC, just like you put it on top of malloc.

It is Java where you are stuck. Not GC languages in general.

<comment><USER20> Manual deallocators are more interesting.

PJSIP[1] has an interesting approach to this. SIP messages have lots of strings associated with them, are usually relatively short-lived, and typically you'll want to modify these strings or attach new ones. PJSIP does this by hanging a string arena off of each SIP message object.

As you add strings to the SIP message, these get appended to the arena, which is grown automatically as and when it needs to be. If you delete a string, it just sticks around in the arena unused. Arena space can also be shared, e.g. if you copy a substring from one SIP header to another, it'll just be referred to twice using a pointer and length.

Finally, when you free the SIP message, it just frees the entire arena in one go.

[1] [http://www.pjsip.org/](http://www.pjsip.org/)

<comment><USER21> Yes, that kind of "transaction-based" memory management is beautiful in applications where it's appropriate: just leak memory until you're done with the current task, and free it in one chunk. That's hard to beat for performance and simplicity.

</comment></comment></comment></comment><comment><USER23> One point that seems to be ignored in this discussion is that having a GC creates problems for interfacing with foreign libraries. It's not too hard to create hooks in the runtime to allow calling C functions, but it's very hard to go the other way, and usually you have to write bridge code in C that links to both the language runtime and the foreign library. And no matter what there will be function call overhead that's unacceptable in some circumstances.

Languages runtimes enable lots of other cool things, like JIT compilation and runtime specialization, user-space schedulers and I'm sure some other things as well, but if, as a language designer, all you want is GC, consider if that's worth all the costs of having a runtime.

</comment><comment><USER24> This article seems like a bit of a strawman.

I don't know of anybody who complains that the cost of actually freeing memory in GC'd languages is somehow significantly worse than in non-GC'd languages. Everybody is ultimately complaining about how expensive it is to figure out what is actually okay to free/release in the first place.

There are plenty of GC-backed languages/runtimes where the GC penalty is isolated or mitigated because of other known constraints of the system. Erlang's no-shared-mutable-state constraints allow its GC system to avoid stopping the world and also allows processes to run on other schedulers while GC is active on a different process running on a different scheduler.

</comment><comment><USER25> One flaw in this article is that it assumes "naive malloc/free use". It assumes that a program written in C and in Java (for instance) will need to perform the same amount of allocations.

This is far from the truth. First, C has nested structs, whereas in Java all object references are pointers. This leads to many more allocations in Java. Second, C programmers are aware of the cost of malloc, and will try to minimize its use. Reusing memory whenever possible is common, as are some simple memory management strategy (such as arena allocation: allocate big chunks of memory, do all your work therein, then free it in one go, for instance at the one of a processing step).

<comment><USER26> > Second, C programmers are aware of the cost of malloc, and will try to > minimize its use. Reusing memory whenever possible is common, as are some > simple memory management strategy (such as arena allocation: allocate big > chunks of memory, do all your work therein, then free it in one go, for > instance at the one of a processing step).

But if you're willing to put the effort in to do something like that, there's no reason you can't do the same thing in Java.

<comment><USER25> Ah but you can't. The GC will still pause and trace no matter what.

As far as I know, you can only control allocation at the level of "retainment": you can keep something from being GC'ed by keeping a reference to it. Potentially you can also reuse memory. So basically, object pools. This is much less efficient than arenas, where there is one malloc and one free (or one per memory page).

Also reusing memory is a bit ugly: you can't specify that things are final anymore, which you can in C -- sure this is no hard guarantee (it isn't in Java either) but it's a useful indication that during the lifetime of a "logical object" (not its memory) it will not change.

I've tried using object pools a couple time in Java, whenever allocations dominated the running time, it never helped any.

<comment><USER26> > Ah but you can't. The GC will still pause and trace no matter what.

The tracing can happen concurrently with the appropriate config. And I wouldn't be surprised if you could disable GC, at least for all practical purposes (e.g. only GC at 100% space usage or every 10000 years, or some such).

> As far as I know, you can only control allocation at the level of > "retainment": you can keep something from being GC'ed by keeping a reference > to it. Potentially you can also reuse memory. So basically, object pools. > This is much less efficient than arenas, where there is one malloc and one > free (or one per memory page).

AIUI you can do that by defining objects backed by an unsafe buffer (technically a non-public API, but there's an understanding that it will be supported and the wheels are turning towards standardizing either it or something equivalent that supports the important use cases).

> Also reusing memory is a bit ugly: you can't specify that things are final > anymore, which you can in C -- sure this is no hard guarantee (it isn't in > Java either) but it's a useful indication that during the lifetime of a > "logical object" (not its memory) it will not change.

I didn't think C supported final at all? I agree that it's less convenient than it might be and a lot less convenient than standard Java, but I'm not convinced it's really any worse than what you'd be doing in C.

</comment></comment></comment></comment><comment><USER27> I think all this time spent over the last 50 years trying to improve GC were a kind of sunk-cost fallacy. Instead of answering the question "how do we make GC better/faster/less laggy/take less memory/not freeze the world/be more deterministic" people should have been investing in "how do we elide object lifetimes so programmers don't have to think about them."

Especially since GC doesn't map to the real world in important ways, for instance OS resources such as sockets/threads/pipes/files. You have to build your own reference counting on top of these things anyways.

This is why I have a lot of hope in Rust -- not necessarily because I see it as the ideal, rather because they are asking the latter question and they've got some pretty cool results.

It's time to let go of 'GC' in the classic sense and figure out how we can elide object lifetimes in a clean, rational and deterministic way.

<comment><USER28> I wish I could upvote this 10 times. In C the programmer has to manage memory which is a chore, but the programmer can do it because they _know_ something about the lifetime of their data. In GC languages that knowledge is sent to /dev/null, then heroic efforts are expended to attempt to machine-re-lean it again at runtime. This is crazy. As you observe, the better plan is to relieve the programmer of the chore of manual management, but do while retaining their knowledge and understanding of the behavior of their code.

</comment></comment><comment><USER29> I'm curious about the following:

 _Here 's how Java allocates an object of size N: round N up to a multiple of 8 bytes, and bump the allocation pointer by that much. That's it. By using a scheme called a thread-local heap (TLH), there is no contention between threads. There's some additional handling for large objects, and for the case when the TLH is exhausted and another one must be allocated, but generally speaking, the GC is self-tuning so that none of these activities appear on the hot path of an application. The overhead is generally negligible, and all you're left with is the pointer bump._

What is to stop someone from implementing something like this in a C library? It sounds like it could be relatively easily done... or is it the TLH that causes issues?

<comment><USER7> You are correct. As I mentioned in [https://news.ycombinator.com/item?id=11426339](https://news.ycombinator.com/item?id=11426339), jemalloc does this ([http://linux.die.net/man/3/jemalloc](http://linux.die.net/man/3/jemalloc), see the implementation notes), and you can use it pervasively so that all your existing malloc-using code links to jemalloc instead of the regular malloc. Ultimately the allocation strategy is an orthogonal concern to garbage collection, it's just that many GCs spend a lot more time worrying about the allocation strategy since they need to.

It actually goes one step further than the TLH and does this round-robin stuff sharing the load between your processes.

</comment></comment><comment><USER30> My issue is that with GC-able languages, people don't seem to care as much with allocating lots of data and expecting the GC to wipe it all away.

To give a recent example, HTML5's canvas API only allows accessing image data with getImageData, which will allocate a large array for you, and then return it. You cannot do this at 60fps, because of GC pauses (and also because Chrome doesn't actually track the memory usage of the ImageData correctly, leading it to run out of memory rather than correctly free the object).

There is no way to pass in a pre-allocated buffer, because the presumed cost of the GC is free. When developers are asked to track memory usage themselves, they're allowed to be a lot more careful with it, and design APIs that take that cost into account.

</comment><comment><USER31> If you need to do some low latency and high throughput stuff, sometimes you just can't afford a garbage collector. Like in many videogames.

</comment><comment><USER32> I will allow that GC can be fast, but you have to work hard and have appropriate language features to keep it "chunky". If you have millions of small traces to follow, the n of your O(n) is going to be big. In contrast a manual collection algorithm can rely on user supplied metadata to free the whole dataset in one instant without having a tracing step.

In apps that need to scale, designing data to be efficiently allocated and freed becomes crucial and the reference by default strategy really falls down.

</comment><comment><USER33> It's been what, 20+ years we've been hearing the theoretical arguments about how automatic GC can be soooo much better than manual or ref-counted heaps and yet... [https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gc...](https://docs.oracle.com/javase/8/docs/technotes/guides/vm/gctuning/g1_gc_tuning.html)

<comment><USER28> I like to joke that you could simply comment out the body of free() in any C/C++ program and achieve 99% of the benefits of GC.

</comment></comment><comment><USER34> One common theme I have seen is all the Big Data Java solutions using home- baked solutions for off-heap storage. This essentially is free-malloc for Java world using sun.misc.Unsafe API.

The problem is Java specs do not dictate native access besides JNI. One standard off-heap API, which provides all the goodies of native world and escapes GC will be a right step. It is upto the dev to choose which world the object lives.

</comment><comment><USER7> This article seems pretty muddled.

First, one reason GCd languages are slow is because they GC more than necessary; not necessarily because of the GC itself. It's not always possible to statically determine what needs to be GCd. Go is pretty good at this, though, especially since pointers are explicit unlike Java. You also have cache issues here. Even if the GC tries to assuage these cache issues by smartly placing objects, this is a far cry from the speed you get from a cached stack.

Secondly, the "GC can free when it wants" is not an indictment of malloc-based heap usage. You can easily plug in an allocator that does the same thing with respect to freeing memory at an opportune moment. IIRC jemalloc does this. You can argue that jemalloc isn't malloc, but since your programming style or language doesn't need to change if you want to use jemalloc over malloc, it doesn't matter -- comparing GC to malloc isn't the real question at hand here, comparing GC to a malloc-like memory management API (or an abstraction over it) is.

Almost all the improvements that a GC has over malloc-like memory management mentioned in the article can be implemented as a policy in a jemalloc-like pluggable allocator. Smartly managing malloc() calls and delaying free() calls is orthogonal to garbage collection, it's just that garbage collectors invariably do this since it's necessary to offset the performance hit of putting everything on the heap.

The only legitimate performance feature mentioned there is that a moving GC can handle the cache smartly. It is true that malloc can't do this. However, malloc doesn't have cache problems in the first place -- managing the cache in a GC is making the best out of a sticky situation; malloc doesn't cause that situation in the first place.

</comment><comment><USER35> This all seems language and implementation specific.

Comparing Go and Java, I have the general impression that garbage collection in Go has reached the point where it just works, while in Java we're still tuning it after all these years.

But part of the reason might be that creating garbage is more easily avoided in Go. Or it might that people are attempting different things.

<comment><USER23> I've been hearing (from other HN comments) that Go 1.6's GC is still considered less performant that hotspot's in the average case, and has significantly worse performance in some select edge cases.

Historically Java competed with C++, and its evolution has been defined by trying to get it to match C++'s performance in the general case. Go prefers simple, sound and obvious to maximum performance.

<comment><USER12> Java is never going to compete with C++ until they have proper memory placement semantics.

If I know how to arrange my data I can beat Java by 50x.

The thing is so few people care(or need) this these days that stuff like the original article gets written.

</comment></comment></comment><comment><USER36> What I'd like is a language that permits me to trap a dynamic allocations with a knowledge of the callsite.

Instead of having specialized objects for manipulating memory (like deque<>, vector<> ...), this language would provide statically a profile (or signature) of the stack at compiletime. It would allow the user to apply strategies that are used in JITs (like inline caching).

For example, detect that an array is push or shift only:

\- if it's push-only, preallocate memory by chunk (like vector.reserve()).

\- if it's shift-only, trap the [] operator and change the head of the array by an offset (no resize)

The issues of GC and malloc are around the context.

</comment><comment><USER37> I've had to use Java for sets and maps of millions of small objects (containing 1-3 integers). The garbage collector choked pretty early after a few (< 20) millions of them (I think there is no way to hash integers in standard Java without significant object overhead).

Knowing almost nothing about the JVM, what's the best approach to go about this? I considered implementing my own sets / maps on naked int[] / structs of 1-3 naked int[].

<comment><USER19> Objects are expensive. If you're dealing with millions of them you definitely want to 1.) use primitives where possible (ie: int, not Integer) and 2.) put those primitives in native arrays instead of collections (ie: int[] and not List<Integer>). It sounds like in your use case that means going from the collection of objects pattern to the object of collections pattern.

</comment></comment><comment><USER38> Someday, when Rust gets its GC interface, we can do some proper benchmarks.

<comment><USER7> It's still apples to oranges, because Rust will only ever have an fine-grained optional GC (you choose what objects s to pop into the GC), not a pervasive one.

<comment><USER38> Well the second step is a make an allocator crate that puts GC in as the system allocator for std.

<comment><USER7> As far as Java is concerned, _still_ apples-to-oranges since Rust doesn't pervasively mallocate either.

Go would be an ok comparison. I suspect Go would come out on top, since it actually tries to avoid GCing things, whereas the Rust compiler wouldn't even be aware that there is a GC going on and wouldn't do any analysis.

<comment><USER38> I mean compare the same rust programs, with jemalloc vs with GC.

<comment><USER7> Ah, okay. That can work.</comment></comment></comment></comment></comment></comment>


Ask HN: What makes it to the RSS feed? - <AUTHOR> I read HN via RSS, but from time to time I visit the front page and see submissions that never make it to the feed. What's the criteria for something to make it to the feed? Is it just whatever happens to be on the front page when it's polled? <comment><USER2> If I remember right, the rss feed "broke" around December of 2017. It had broken several times before then as well, but nobody fixed it this time.

The result is that almost nothing on the hacker news front page makes it into the RSS feed on a daily basis. Maybe three or four random posts get in but that's it.

The bigrss feed still works but that's all submissions, trolls, re-posts, garbage, and all.

Basically, it's broke. Sorry I don't have anything more helpful to say but it's been abandoned.

<comment><AUTHOR> It's not broken though, I use it to read HN daily.</comment></comment>


Adioso (YC W09): founded on persistence, abandonment of bad ideas, and naivete - <AUTHOR> http://delimiter.com.au/2010/09/13/monday-startup-adioso/

<comment><USER2> Thanks for posting the article Tom. I'd say persistence, abandoning bad ideas and a healthy dose of naivete (not knowing enough to be scared to try) are necessary for most startups. Well done on Adioso version 3. Just gave it a spin and it's working great. Once again I'm inspired by the startups good old Melbourne, Australia is producing (almost in spite of itself).</comment>


Twitter's Root Injustice - <AUTHOR> http://techcrunch.com/2014/03/02/twitters-root-injustice/

<comment><USER2> Nobody I follow on Twitter thinks like this. The idea of a Twitter account having some intrinsic social capital baffles me. The "old" Twitter accounts? The "new" Twitter accounts?

I follow Daniel J. Bernstein (@hashbreaker, a relatively new account) because he's Daniel J. Bernstein. I am interested in what DJB has to say.

I am in conversations with other people who are interested in what DJB has to say. We comment on the same threads. They wind up in my feed. Not infrequently, one of those people will say something interesting. I will click the "follow" button. Others do the same. Their follower count grows.

In what other way could this system meaningfully work? Why on earth would I follow someone because of their Twitter stats? What do I care how Twitter manages those stats? If you want a chance to be heard, say something interesting.

</comment><comment><USER3> This is kinda like saying people with more contacts in their cell phones have more social capital, and the carrier should address that.

</comment><comment><USER4> Whether this is a problem is debatable, but referring to it as 'Injustice' is entitled and inappropriately hyperbolic.

<comment><USER5> Injustice: "a quality relating to unfairness or undeserved outcomes. The term may be applied in reference to a particular event or situation, or to a larger status quo. In Western philosophy and jurisprudence, injustice is very commonly, but not always, defined as either the absence or the opposite of justice."

[http://en.wikipedia.org/wiki/Injustice](http://en.wikipedia.org/wiki/Injustice)

Justice "is a concept of moral rightness based on ethics, rationality, law, natural law, religion, equity and fairness."

[http://en.wikipedia.org/wiki/Justice](http://en.wikipedia.org/wiki/Justice)

An entitlement "is a guarantee of access to something, such as to welfare benefits, based on established rights or by legislation. A "right" is itself an entitlement associated with a moral or social principle"

[http://en.wikipedia.org/wiki/Entitlement](http://en.wikipedia.org/wiki/Entitlement)

Criticizing an inherently moral concept on the grounds of a claim to morality is ... somewhere between irrational and ignorant.

<comment><USER4> Next paragraph:

 _In a casual sense, the term "entitlement" refers to a notion or belief that one (or oneself) has a right to some particular reward or benefit— if given without deeper legal or principled cause, the term is often given with pejorative connotation (e.g. a "sense of entitlement")._

[http://en.wikipedia.org/wiki/Entitlement](http://en.wikipedia.org/wiki/Entitlement)

<comment><USER5> It does but as a secondary sense. I still find the criticism voiced wanting.

</comment></comment></comment></comment><comment><USER5> First-mover advantage is a characteristic of a great many systems. Disrupting that, out of concerns for justice or merely to provide a more compelling reason for newcomers to make use of a service or tool, is an interesting and ongoing challenge.

Another approach is to randomly present new content to users. Google's attempted numerous hacks to both solve the "empty streams" problem and break out of filter bubbles at G+, though many of these have been less than satisfactory. The "What's Hot" feature (now deprecated to "Explore") had the typical problems of juvenilia and vapidity, as well as the problem for those whose posts were promoted to it of attracting vast amounts of generally unwanted attention, to the extent that people were begging _not_ to have posts featured.

It's not a specific problem of Twitter, there's a challenge in new-content discovery and promotion generally. I'm not sure that the "active users" hack is a sufficient fix. I do feel that leveraging both technical (e.g., algorithmically determined ratings) and social (FOAF type recommendations) tends to produce more useful results.

</comment><comment><USER6> This is the author of the post. would love to take any questions.

<comment><USER7> You make some very interesting observations. I'm pretty sure the folks at Twitter spend a LOT of time working on user engagement and solving the signal vs noise problem in recommendations etc. What's been their response so far when you reached out to them? I would try to reach out to the people trying to solve this problem (developers) instead of to management first, in case it's not a matter of decision making but a more of an algorithmic problem.

</comment></comment><comment><USER8> Why would everyone on Twitter have imperial ambitions?

</comment><comment><USER9> The _world_ operates as an unregulated market for social capital. To blame Twitter for that is a little absurd.

<comment><USER10> Social capital is still capital. If social capital is what draws users to Twitter, then Twitter's user engagement as a whole determines the value of its shares. If new users aren't able to gain that capital through Twitter, then Twitter's userbase will begin to stagnate, and its stock value will drop. Regardless of who's to "blame", this is undeniably a real problem.

<comment><USER9> I think that's a problem with an inter-networked world in general. Time and attention is finite, and there are now many sites, apps, and people competing for that attention. What you describe is every as relevant for aspiring YouTubers, bloggers, etc.

I agree that Twitter is included in that overarching problem, but I don't see it as their creation, and I'm not sure what they can do about it. (Facebook is in an easier position, being oriented primarily around family and friends, even though every brand on Earth also has a Facebook page.)

<comment><USER10> I wasn't talking about a general problem with capitalism. I'm saying that this is a unique problem that Twitter as a company has to face, for the reasons the article describes.</comment></comment></comment></comment>


PunkProgramming – Looking for people who want to start coding - <AUTHOR> Hey there!
I'm currently working on a 90s style _printed_ programming zine and I'm still looking for 2-3 people who want to learn how to code and who also have an original (as in - no uni homework, no business things, you'd also be ok to open source it) idea for a project they want work on.
My goal is to feature their progress and (hopefully) motivate other people to try coding by doing so... E.g. showing the reality of how frustrating it can be when just starting out and that this is just normal. - But also showing how _super_ rewarding it is, when you finally got something to work!
I have experience in hardware (all kinds of micro controllers and vintage computers) and most web things (frameworks, servers whateverrr) aand I know loads of people across fields, including e.g. biotech and shader people.
So whatever crazy idea you might have, tell me and we can work something out. (As long as it's not _too_ complex... and manageable over a period of 4 weeks)
Note that, if you're interested,  you will have to figure out most things by yourself along the way... but my friends and me will lend you a hand with the basics in the beginning and give you hints when you feel you're _completely_ lost and stuck.
Thanks fore reading! :) <comment><USER2> Check my project [https://github.com/leonardoruilova/costofliving](https://github.com/leonardoruilova/costofliving)

My blog (spanish language) is [https://leonardoruilova.wordpress.com/](https://leonardoruilova.wordpress.com/)</comment>