Ask HN: Where can I find a list of colleges YC founders have gone to? - <AUTHOR> I'm curious as to see how many my school has sent compared to our neighbors. <comment><USER2> I went to U of I. There were a number of founders from Waterloo in the last batch.

</comment><comment><USER3> 1) The School of Hard Knocks</comment>


Huge blow to Irish import stores in U.S. as Cadbury is banned - <AUTHOR> http://www.irishcentral.com/news/Huge-blow-to-Irish-import-stores-in-US-as-Cadbury-is-banned.html

<comment><AUTHOR> American mass-market chocolate is so deeply inferior to chocolate in other parts of the world. They should be embarrassed to stoop to this level, though given the shared trademarks and exclusive brand agreements I understand why the court may have gone this way.

It's not surprising, however, that their instinct was to sue rather than simply make better chocolate. Making better chocolate costs money, which adds up over time. Though I can't imagine why anyone would ever buy most Hershey's products. They're generally awful, over-sweet, and gritty.</comment>


What Google know about us - <AUTHOR> http://techunzipped.com/google-knows/

<comment><AUTHOR> are we giving social-networking to much information? what can be done to change this?</comment>


Why not to use Excel for Data Gathering - <AUTHOR> http://caseelse.net/2008/08/06/why-not-to-use-excel-for-data-gathering/

<comment><AUTHOR> Great Quote: "This kind of project is a knock-off for a web-developer. It's a career for a scripter."

</comment><comment><USER2> Excel actually can do data validation. You can allow input only on certain cells, and allow the input to take values only in a range. Alternatively, you could do the validation in VBA.

</comment><comment><USER3> Thanks for posting my article here. I had no idea it would generate interest =]

Yes, Excel can do all sorts of data validation, etc. What wasn't clear in the article (I didn't know I was writing for public consumption) is that the projects in question are ongoing surveys reaching (potentially) literally tens of thousands of people.

But GavinB, I agree with you; and would like a one-second fade for data validations on the web page, also.

</comment><comment><USER4> One good way to get people to enter data the right way is to use conditional formatting to make it change a color when they enter the word that you want. It's very satisfying to turn a line from yellow to green (in progress to complete for instance) and gives feedback as to whether the form is being used correctly.

Which is not to say that a web form isn't a better way to do it.

</comment><comment><USER5> Also, you could use CSV, though it's not a great idea (parsing CSV is a nightmare, maybe using the right libraries it stops being a bad thing).</comment>


Show HN: Skynet Today, a site for informed and accessible coverage of AI news - <AUTHOR> https://www.skynettoday.com/ <comment><AUTHOR> Hi HN!

Been working on this project for a while, hope you dig it!

Also, everyone working on it does it in their free time, and we could still use more help (with front end dev too!) , please get in touch if you might be interested - [https://www.skynettoday.com/contact](https://www.skynettoday.com/contact)

<comment><USER2> I dig the name of the website/project most of all! There's an alternate universe out there where Skynet announces their nuclear strike on humanity via Skynet Today.</comment></comment>


F# 3.1 as C# 6.0 Strict Mode - <AUTHOR> http://simonhdickson.github.io/blog/2014/02/27/fsharp-31-as-csharp-60-strict-mode/ <comment><USER2> Strange post, or maybe I'm missing the point, or is it supposed to be sarcastic? Also what's with the generalisations ('enterprise shops don't like change & non-enterprise do', come on)?

 _half assed versions things of F# already had (tuples, async and tasks I'm looking at you)_

yes F# has those, but afaik so do a myriad of other languages. Even before F# saw the daylight. I'm also not sure what is half assed about them, the implementation seems quite complete?

 _a language that is afraid to change anything_

coming from a post talking about new features and 'changing into F#' that's quite a contradiction, no?

<comment><USER3> i think you're missing the point a little bit.

> yes F# has those, but afaik so do a myriad of other languages. Even before > F# saw the daylight. I'm also not sure what is half assed about them, the > implementation seems quite complete?

it's true, but c# advocates in microsoft have been quite parasitic in their behavior of pushing the language(inside of microsoft). they have also been averse to competition. i remember it's not too long ago, that we weren't really sure if microsoft was about to pull the plug on f# or not.

there haven't been too many clr languages, and ironpython was suffocated fairly quickly. yes you can use clojure on the clr, but who's using that, and is a meaningful customer to microsoft?

f# has been really smart in it's behavior in my opinion, by fairly quickly targeting the microsoft enterprise stack, stuff like share point, dynamics, and other crap like that.

it's also a hybrid language that is close enough to c# that you can claim c# developers can just pick it up. you could argue that good developers can pick up any language, but we're not talking about good developers here. we're talking about something that is more akin to factory work.

this is just my opinion, but i think the biggest customers of microsoft are government, government contractors, and people that sell to government contractors.

it's not about whether f# is really revolutionary or not. f# is very close to ocaml. f# is revolutionary to the microsoft enterprise stack.

asp.net mvc wasn't revolutionary either, but it was revolutionary to the .net culture.

take a look at some posts describing alt .net [http://msdn.microsoft.com/en- us/magazine/cc337902.aspx](http://msdn.microsoft.com/en- us/magazine/cc337902.aspx)

<comment><USER4> I've been using C# for close to a decade at this point (wow, wtf) and I'm fairly familiar with functional programming techniques - I use a lot of closures, immutability, and map/reduce patterns in my code - but F# is still really awkward for me to write and use compared to C#. Even if they can express the same things, and F# is more powerful, it's a far more inconvenient language to use for someone that hasn't been living and breathing ML for years.

Furthermore, in general F# seems to generate far less efficient code than C# does, and for the kind of development I do (games/multimedia) I'm not really willing to sacrifice even more performance just because some FP fanatic thinks C# should go away. Personally, I think the C# compiler and the .NET JIT should have a lot more tuning applied, and get things like SIMD introduced, but MS doesn't seem to care about that.

Writing code in C# also makes it accessible to a much wider set of developers. The overlap and shared heritage with languages like Java is definitely a plus, even if I don't like some of the shitty design baggage that comes with it. It's already a struggle to get the community engaged with my project, JSIL - if it was written in an obscure language like F#, it'd be nearly impossible.

<comment><USER5> If you're seeing significantly worse performance with F#, then that's pretty unusual (most people see very similar perf characteristics, with some things slightly faster in F# and some in C#). You might want to fire an email to firstname.lastname@example.com explaining your scenario - the F# team is quite responsive.

The RyuJIT project shows that .NET JIT performance is still on the radar, though I haven't seen any indication that SIMD is on the roadmap.

To your final point, it's clearly true that C# is familiar to a wider variety of developers than F# is. However, I've been impressed by the uptake of some F# libraries, like FAKE. F# reads so mush like pseudocode in some cases that it's easy for people to buy in even if they're not especially familiar with the language.

<comment><USER4> Glad to hear it. The main problem I noticed the last time I used F# is that it generates more function calls, along with more heap references (vs stack- allocated structs) for things like boxed values, generators, etc to do simple tasks compared with C#. Is it the case that you can optimize all this out using parts of the language I don't know about?

<comment><USER5> F# supports value types just like C# does, so I wouldn't expect more boxing on the F# side. Some types like tuples that are used more in F# than in C# are reference types, so you might want to avoid them in your inner loops, but that generally just means writing F# that looks a bit more like C#. Likewise, as to the number of function calls, it's probably a question of style more than features, though you can do things like use the `inline` keyword to make sure that particular functions always get inlined at call sites, which can be a big win in some cases (it also allows you to write type-safe generic math code, which is an oft-lamented unsupported scenario in C#). Lots of people are making good use of F# in contexts where heavy computational requirements exist (e.g. finance or scientific computing), but I'm not too familiar with projects using it where more real-time requirements exist (though I think someone's in the midst of porting Quake III to F#, so it'll be interesting to see how that goes).

</comment></comment></comment></comment></comment></comment><comment><USER6> It's trying to be F# except the whole part about not being functional which is why most people will not switch to F#. Instead, we rather use the language that has worked well for us but want it to have useful features that some other functional languages happen to have.

<comment><USER7> IMO one of the most useful features of FP languages is type inference. I'm not sure you can cherry-pick that.

<comment><USER8> Type inference is not an exclusive feature of FP languages, though there is no known system that can deal well with nominal subtyping (scala makes a good go at it, but only locally).

<comment><USER9> What would you say is the usefulness and value of local inference vs global inference?

In my experience, local inference eliminates a lot of boilerplate and clutter, while global inference isn't so important, because writing types is good documentation as you zoom out from the details of functions.

<comment><USER10> It also emphasizes the importance of good tooling support: when using global inference it would be cool to always show the inferred types as a little semi- transparent text on the top...

</comment></comment></comment></comment></comment><comment><USER11> I just wish C# had algebraic types. That's the only thing keeping me looking for another programming language right now. Everything else, I love. But I do a lot of runtime reflection right now that is really only necessary because C# generics are not a powerful enough type system to represent what I want succinctly.

So I might end up implementing a lot of things as F# libraries glued together by C#. I'd prefer not to have that bit of context switch there, and I've had some trouble getting the F# compiler to work with Visual Studio on all of my machines (my Windows 8 machine was fine, but my two Windows 7 setups are broken).

Okay, that's not the only thing. I really want macros. Lisp-style, not C-style. I don't care if they are "considered dangerous" to lowly corporate developers. They can pass corporate policy against their use. That should be no reason to keep them out of the hands of adults.

<comment><USER12> Could you elaborate a bit on what you are building? Sounds fairly interesting.

<comment><USER11> The algebraic types wish is to be able to do scientific calculations more safely. I have built a system figures out the maximum safe speed limit for a car on a tight curve, and having the compiler validate my units of measure would go a long way towards ensuring the quality of the formulae over time as we tweak it.

The wish for a macro system is a different story entirely.

For the last, ooooh, 7 years or so, I've been building a relational data access system that I have come to realize is an attempt to build a static type checker for SQL queries. It's not quite to that level yet, but right now, for me it's the most convenient way to make type-safe access to a relational database. I also think it is a very convenient way to manage change of schema over time.

I know, every hot-headed developer makes his own "ORM", but I had some specific uses cases that made sense for me to roll my own system. At the time, the only options for data access were ADO.NET [0], NHibernate[1], and a slew of NHibernate clones[2].

I needed the ability to execute fairly arbitrary SQL against a slew of databases whose schema was off limits to me. I could make all the stored procedures I wanted, but i couldn't change any tables. I needed a better way to manage those stored procedures through different environments, for versioning and for regression testing if parameters changed. And I needed it to automatically manage things, so the idiot developers on my team wouldn't screw shit up with raw ADO.NET calls.

So I created SqlSiphon: [https://github.com/capnmidnight/SqlSiphon](https://github.com/capnmidnight/SqlSiphon)

In the last couple of weeks I've managed to break a few of the features, but I'll be fixing them soon[3].

You define parameterized queries directly in your data access layer. These get translated into stored procedures whose name and parameters are gleaned from the sameness in your data access layer, e.g. "public UserPref GetUserPreferences(int userId){}" in C# will be used to generate a stored procedure in the database named GetUserPreferences that takes an integer parameter and selects out values that can be mapped to a structure called UserPref.

You define C# classes that map to your query views. This is why it's not an ORM: there is no attempt to resolve foreign key references to build an object graph from a query. This is also why it's fast enough for my needs: it is only a system for executing traditional SQL.

It supports SQL Server, Postgres (in master, will be fixing in dev), and MySQL (ditto). It can query from OLE DB sources like Access database. It is easy to extend to support querying from any database, as long as an ADO.NET driver exists for it. It is only a little more difficult to extend to support code generation for other databases.

At one time, it was able to analyze a database on, say, SQL Server, recreate the database in Postgres, and copy all of the data over. It lacks it now, as I had built it as a propriety extension for a client, but will be getting it back soon.

My immediate goal with the project is to create a type-safe way to manage correct database design across environments. It's all about the DRY principle. I'm very close to that goal, and even right now I think it's far better than using anything else, given the tradeoffs.

My long term goal is to make it into a system for breaking database vendor lockin. Once I have a system for analyzing query structure directly, I believe I'll be able to translate the majority of queries transparently between databases[4].

And it might not happen tomorrow, but I'm fairly certain it will eventually happen. If you told me 7 years ago that I would have made this thing that currently exists, I would have never believed it. But it's all features I need, and I make more and more progress every year, so I feel pretty confident that it will eventually get there.

[0] Which everyone used incorrectly--not disposing all of the associated objects properly, doing string concatenating for parameters, etc.

[1] Which had just started to prove out the problems of object-relational impedance mismatch.

[2] That were even worse performance-wise, and ORM in general is really only good for brand-new CRUD apps.

[3] That is no empty promise. I've broken things I need, so I will certainly be fixing it again. At any rate, the master branch is "stable" right now and will eventually be forked as "1.0", with the dev branch pretty soon getting stabilized and becoming "2.0".

[4] Or at the very least, create a SQL subset for which it can be done that guides developers into making structurally sound queries. Most of the problem with poor database performance comes from poor database developers writing poor queries. Most of the work for porting an application from one database to another is dealing with those shitty queries.

<comment><USER13> Interesting, sounds like Scala could fit the bill, algebraic data types and macros included ;-)

Plethora of type safe query libraries to choose from as well. No easy interop with .NET, however.

Saying that, why not LINQ-to-SQL or whatever the latest and greatest is from Microsoft, Performance?

<comment><USER11> Quite a few reasons. Originally, I was stuck on .net 2 (.net 3.5 had only just come out), so LINQ wasn't available. Then, for a long time, LINQ to SQL was not thread safe. It doesn't generate stored procedures, so there is a significant network overhead for complex queries and complex queries can't be shared across language independent projects. And finally, my system provides a ton of metadata that I could then start leveraging for script generation. Entity Framework was too all-or-nothing, and my own system had too much momentum for me by that point. It has evolved over time and it has always just been easier to adapt it than to take on whatever has been popular at the time.

</comment></comment></comment></comment></comment><comment><USER5> I love F# dearly, and despite having spent several years writing C# code earlier in my career, I still find switching back to C# from F# painful in lots of little ways.

But I think this post is off-base. First, it criticizes C# both for incorporating too many of F#'s features, but also of stagnating. I just don't see how anyone can consider C# to be stagnating... of the heavily-used-in- industry set of languages, is there any that's evolving faster? Java's just now getting lambdas, for instance!

Secondly, I think the lack of promotion of F# by Microsoft is somewhat lamentable (though the community has done a great job of picking up the slack). But I think Microsoft's in a bit of a bind - they've received a lot of criticism for having too much churn in the ecosystem (e.g. ADO -> ADO.NET -> LINQ-to-SQL -> LINQ-to-Entities). So how would the community react to the statement, "you should really be using F# instead of C# going forward" (even if decision makers believed that)? Undoubtedly people would feel that the investment they'd made in learning C# was not worth as much as they thought and they'd start looking into more stable ecosystems (I'm mainly referring here to LOB app developers, who seem to greatly value stability of their platform).

Furthermore, in some ways these changes make the on-ramp from C# to F# even easier, which is a good thing. And C#'s still missing so many great F# features that it doesn't make sense to get too worried about the ones that have been mimicked. And I think it's somewhat true that imitation is the sincerest form of flattery, and having many great features spreading to other languages is a good thing.

</comment><comment><USER10> Every new C# version there is less reason to switch to F#. I have considered it multiple times but sacrificing ReSharper would be too much of a trade off for what F# is offering.

</comment><comment><USER14> The article referenced by this article lists nine features of which eight are syntactic sugar. (Being able to declare the out parameter in place has a very minor but significant impact: Preventing abuse of a variable intended to be used as the out parameter.)

It's disappointing to see the team spend its time on so many minor features rather than tackling fewer major improvements.

I'm sure we all have our pet features. My wish would be structural typing: Very few of the C# developers I've worked with in the past couple of years have embraced isolation testing. A significant reason is the frustration with "extra" interfaces and the distractions they introduce in code navigation. Anything that eases the the uptake of isolation testing would dramatically improve software quality, which as we know, would dramatically improve our efficiency.

<comment><USER15> Structural typing would be nice. My wish would be algebraic data types. I'm not sure how that would even work in c# but its what I want :)

I tend to avoid using out parameters. I've written extension methods to replace the typical out param framework methods.. For example, instead of int.parse(string s, out int i), we have "123".TryParse<int>(), which returns a nullable int. instead of TryGetValue on dictionary, we have GetOrDefault(key, optional default val) and GetOrDefaultAsNullable(key).

I think the new out parameter syntax is an improvement, but I'm still on the fence about whether out parameters are even a good idea when we can instead return a single type that encodes the same information.

I'd be interested in hearing other viewpoints on this.

</comment></comment><comment><USER16> Looks to me like it's simply growing into a many-featured multi-paradigm language, much like Scala.</comment>


ASK HN: How do you retain the knowledge picked up? - <AUTHOR> Hi,
I'm aged 40+ years(18+ years of software development experience). I am passionate about technology and keep reading blogs, articles, yc,... but the problem is that I forget what I pick up in two days. It gives a impression that I'm kinda dull. Not sure what is causing it.
I need help. Please share your thoughts and suggestions on how I can retain more knowledge?
Thanks in Advance. <comment><USER2> Take some form of notes. If something is interesting note it. I use pinboard and tag the link with relevant topics so I can get back to it later. Whatever note system you want to use, make sure its searchable. If it's interesting enough, apply it in some form, a mini-program, a essay to your self on why it might be interesting, or some of the other suggestions here.

Finally, if this trouble is new or slowly growing, talk to your doctor...

</comment><comment><USER3> By applying that knowledge and by teaching it to others.

There's truth in the saying that if you want to become an expert at something you should teach it to someone else. As an experienced software developer there are lots of ways to do this:

\- Coach your clients / colleagues.

\- Offer professional training and workshops. Training developers in new technologies, techniques and frameworks is a lucrative business.

\- Offer non-profit programming classes for children / students.

</comment><comment><USER4> The question is why would you want to clutter your brain with all those details. If you need an information that you've read about in the past, you already have a head start and know there was something written about that and where to find it. And if you don't need those information in the future, what does it matter that you've forgotten it.

</comment><comment><USER5> When I'm learning something new I try to take notes by hand or type them up. Every few days I'll rewrite what I learned from memory, as much as I can remember. Then I'll compare my current notes to my previous notes and fill in the gaps that I skipped. I repeat the process every few days until the information is ingrained in my memory.

</comment><comment><USER6> Use it frequently. Memory patterns form by applying knowledge. Help some open source projects using the topics you learned. Nothing magic.

</comment><comment><USER7> You have to use it to retain it, imho... and don't be too hard on yourself, if you don't remember it, maybe it was not worth the brain cells...

</comment><comment><USER8> i think the best memory yet is understanding and visualization. The human brain is really good at visual tasks and if you have noticed understanding really goes hand in hand with visualization.

</comment><comment><USER9> you acquire long lasting knowledge by doing.

reading only gets you so far.

if you want to retain read knowledge, take notes. what you write down is what you will remember.</comment>


Emudore: a C64 emulator written from scratch using C++11 and SDL2 - <AUTHOR> https://github.com/marioballano/emudore <comment><USER2> This is a cool project with nice, simple code. However, the submission's title (perhaps counter to the README) makes it seem like a good example of C++11, and I would caution against using it that way. From a cursory examination, and with all due respect to the author, this code is more classical C++ with a few uses of C++11 features than it is representative of how modern C++ (at the time of C++11's publication) should be written. There are a few areas where the code could be updated: adding tests, avoiding manual memory management, making it so objects cannot be created in invalid states that would cause crashes, const correctness, etc.

By way of explanation, I'll focus on just the issue of manual memory management. Simplifying a bit, consider this part of the C64 class's implementation:

        C64::C64()
        {
          cpu_  = new Cpu();
          mem_  = new Memory();
          cia1_ = new Cia1();
          ...

          cpu_->memory(mem_);
          cpu_->reset();
          ...

          cia1_->cpu(cpu_);
          ...

          mem_->cia1(cia1_);
          ...
        }

        C64::~C64()
        {
          delete cpu_;
          delete mem_;
          delete cia1_;
          ...
        }

The contract in this code is that a C64 owns the chips, the chips are born when the C64 is instantiated, and when the C64 dies, the chips all die along with it. There are two approaches for making this contract explicit, one is to simply not use pointers and references at all:

        Cpu cpu_;
        Memory memory_;
        Cia1 cia1_;

But this does mean we can't use polymorphism within the C64 class, we don't have nullability, and we can't replace the instances. The code doesn't leverage any of these, so that may be an appropriate choice. However, if we need any of those things, we can instead use the appropriate smart pointer:

        std::unique_ptr<Cpu> cpu_;
        std::unique_ptr<Memory> memory_;
        std::unique_ptr<Cia1> cia1_;

In either case, C64's destructor is no longer necessary. The other classes still take raw pointers (e.g., `Cpu*`) because they do not own the objects they receive and do not dictate lifetimes.

It's worth mentioning that many people would use `std::shared_ptr` here instead, but I think that's abuse that leads you towards circular references (memory leaks): the Cpu doesn't own its Memory, they just have their lifetimes managed exterior to them. This would actually come up with the existing design (if shared ownership were used), since the object dependency graph (which is perhaps another issue) has several circular dependencies.

<comment><USER3> On this topic, I'd like to get the advice of some HN C++ gurus.

In my own emulator (higan), I have a namespace for each emulated system, and each component is its own unique object. Example:

        namespace GameBoyAdvance {
          CPU cpu;
          PPU ppu;
          Cartridge cartridge;
          ...
        }

The obvious downside is that they aren't instantiable. You can only have one instance per process. Generally this isn't a problem for an emulator, but it's still something I don't like about my code.

The obvious "proper" way would be something like:

        class GameBoyAdvance {
          CPU cpu;
          PPU ppu;
          ...
        };

But there's a reason I don't do this: all of the chips need to communicate with one another. So PPU::scanline() may call CPU::raiseInterrupt(Interrupt::VerticalBlank) for example.

So you think something like:

        class GameBoyAdvance {
          CPU cpu{this};  //hooray C++11, this would be
          PPU ppu{this};  //much nastier in C++98
          ...
        };

And now your code goes from this:

        void PPU::scanline() {
          cpu.raiseInterrupt(Interrupt::VerticalBlank);
        }

To this:

        void PPU::scanline() {
          gameBoyAdvance->cpu.raiseInterrupt(Interrupt::VerticalBlank);
        }

Which aside from being a lot of extra typing (seriously, the chips in emulated hardware communicate _all the time_ , all over the place), is also quite a lot slower.

The former can basically get inlined 100%. The compiler knows the exact address of the CPU object, because there's only one. The latter has to go through a pointer to get the address. Even though it's always a constant under actual emulation, the code basically has to account for the fact that you _could_ change the pointer at any time. Even if you tried binding it as a reference, eg CPU(GameBoyAdvance&), the performance penalty remains.

Long ago, I wrote some #define wrappers so I could say "cpu().raiseInterrupt", and depending on compilation flags, it would use CPU cpu; or CPU* cpu; and the results were dramatic: at least a 15% loss of performance just by using the pointer version.

I'd really like the benefits of the latter design, but without the added red tape and performance penalties. But I can't think of any way to pull it off. I _really_ can't afford the performance penalties, as I use 100% of top-end CPUs to try to emulate every hardware nuance possible already. Am I doing the right thing, or is there a better way?

<comment><USER4> It's a bit horrible and unsafe, but you can use offsetof and some nasty pointer casting to get from a member of a class back to the class. I've done this, and it compiles to extremely efficient code. You can even template a class on the value of offsetof, so you can use the same class as multiple members.

I'm on my phone, so no code examples (sorry). If you want one, reply and I'll write one when I get to a computer!

</comment></comment></comment><comment><USER5> There is really not a shortage of open source high quality C64 emulators. Does this one bring anything unique to the table?

<comment><USER6> From a user's perspective, it sounds like no:

"many of the more advanced games written in ML [machine language] do not yet play well due to unimplemented hardware features, writing an emulator is a tough task and after all my goal wasn't to write a full perfect emulator but to learn in the process of making a simple one"

The parent is getting downvotes, but I think it's a reasonable question: is this a program I should appreciate as an amibitious project and potential learning tool, or one I would actually want to use on a regular basis?

<comment><USER7> from the readme:

"I don't think anybody would ever dare to use this for an actual useful purpose, but just in case, the project is licensed under the Apache 2.0 license"

"Long story short: to learn a bit more about computer architecture, graphics, C++, etc.. while having some fun!"

"Due to some of the aforementioned facts, expect things to fail,"

It seems that the readme pretty much states that this is a WIP for learning, and shouldn't be used for anything.

</comment></comment></comment><comment><USER8> Speaking of C64, check out this entry which was submitted yesterday:

[https://news.ycombinator.com/item?id=11521609](https://news.ycombinator.com/item?id=11521609) ('The 64' – A modern C64 console and handheld project)

</comment><comment><USER9> Run it through emscripten, put it on the Archive for C64 games like they have for dos games?</comment>


Counterfeit Game Sold on Apple's App Store - <AUTHOR> http://blog.wolfire.com/2011/02/Counterfeit-Lugaru-on-Apple-s-App-Store-developing?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed:+WolfireGames+(Wolfire+Blog)

<comment><USER2> tl;dr: the art/sound/etc. assets may have been accidentally released under the GPL because of a file omission in the .zip version of the source release.

From the article: " _According to Kotaku, they are talking about the GPL release of the source code for a number of the Humble Indie Bundle games, namely this post. However, the license made it very clear that the authors retained all rights to the assets, characters, and everything else aside from the code itself._ "

Disclaimer: I'm not a lawyer, I might be wrong here about some things, so please step in and correct me if anyone knows better.

So, here's the thing. Looking at the source .zip linked at <http://blog.wolfire.com/2010/05/Lugaru-goes-open-source> (the .zip file itself is at <http://akamai.wolfire.com/humble/src/lugaru-srcs-final.zip>, so that's an official release), I see COPYING.txt, the generic GPLv2 statement, sitting at the root of the project .zip. By custom, I would naturally assume that unless that license is overridden somewhere, it's the license in effect for all copyrightable materials included in nested directories.

I'm not positive about this legally speaking, but I'm _pretty_ sure that if the code is distributed in such a fashion, and most people familiar with code would interpret the license to apply in such a manner (to everything in the subdirectories, unless overridden somewhere within the released code), I can safely assume I've been granted that license.

Now, I fully believe that Wolfire never intended to release the art/sound/character assets under the GPL. But - and I encourage people to check for themselves to make sure I'm not missing something, I could definitely be wrong - _there appears to be no license statement anywhere inside that particular source distribution (<http://akamai.wolfire.com/humble/src/lugaru-srcs-final.zip>) that puts any of those assets under another license_.

I suspect the file at [http://hg.icculus.org/icculus/lugaru/file/97b303e79826/CONTE...](http://hg.icculus.org/icculus/lugaru/file/97b303e79826/CONTENT- LICENSE.txt), the one that sets the license terms on that data, is what the author of the post was referring to when mentioning the clear license terms.

But someone forgot to copy it from the hg repo into the .zip file before they released it.

Unfortunately, they didn't forget to put COPYING.txt in at the root, which means GPL2 for the whole shebang (the default license would have been none at all, but for the presence of that file). If I'm right, and no other license is hiding somewhere, then as far as I can tell (not a lawyer) those assets are under GPL. It doesn't matter if comments elsewhere clearly prove that the GPL was only supposed to cover the code, a release was made and linked by the original copyright holder with a license statement whose clearest reading grants the user a license to _everything_ under the GPL. Prevailing wisdom seems to be that you can't take back a GPL license, so yes, that means that all the assets in this game have been accidentally open sourced.

There's still a trademark claim, of course, this joker can't legally call his game Lugaru, but if he renames it, he's within his rights to try to sell it as long as he branched from the .zip release (though the GPL issue might keep it off the App Store).

<comment><USER3> I did a quick search if the USPTO database and the name Lugaru isn't trademarked yet. So iCoder may have a case. Best defense might be to complain that the GPL is incompatible like the VLC coder did.

<comment><USER4> That's not the end-all, be-all of trademark law though. If Wolfire had a registered trademark, it would make things easier for them.

But, they have been conducting trade using the Lugaru mark so they have an implicit trademark on the term Lugaru as it applies to video games. It's the difference between the TM symbol and the R with a circle around it.

Wolfire can still hit them up with some trademark violation lawsuits and should probably do so soon to avoid problems down the line.

</comment></comment></comment><comment><USER5> I still don't understand why they don't send a DMCA takedown request to Apple and call it a day. Have they already done this yet Apple is refusing to takedown the offending app? I highly doubt Apple would take on that sort of liability.

<comment><USER6> I think the probable outcome is "Wolfire -> Apple: DMCA", "Apple -> Pirate: You've been DMCAed.", "Pirate -> Apple: Counter-notification. We believe we have a valid license. The DMCA says that they have to sue us to prove otherwise.", "Apple -> Wolfire: Well crikey, they're right."

That leaves Apple legally covered, although I would bet they terminate the pirates under the It's Our System And You're Causing Us Negative PR So Eff Off provision.

<comment><USER7> No, that's not correct at all.

Under OCILLA/DMCA, counter-notification _cannot_ be accepted by your provider and is _not_ legally usable unless access to the alleged offending material has been _completely prevented_. 17 USC 512(d)(3). The material must _stay_ removed _completely_ for at minimum 10 (ten) business days and at most 14 (fourteen) business days to allow the complainant to file suit or otherwise obtain an injunction if they so desire. 17 USC 512(g)(2)(B) and (C). That's with a counter notice; without one, the material can never be restored.

So, your scenario then becomes:

        - Wolfire > Apple: DMCA
        - Apple > Pirate: We have received a DMCA and removed it
        - Pirate > Apple: Counter notice
        - Apple > Wolfire: Here's a counter, we will restore in 10 days unless you sue
        - (10 business days)
        - Apple > Pirate: OK, it's back

After the waiting period, you or the provider can restore access with the DMCA's blessing. DMCA only requires providers to "act expeditiously" to remove access to material, so what "expeditiously" means is left to interpretation. I doubt Apple would leave anything up for long, though.

When you get a serious DMCA complaint -- meaning, not one of the automatic- fire BitTorrent ones from MediaSentry or whatever -- try a counter-notice without removing the content and see what your provider does. If they abide by the law, they'll immediately reject it and ask you politely to remove the content, or they will for you.

But wait, you say, doesn't that encourage frivolous DMCA complaints to remove content from the Internet that I do not agree with? All I have to do is file a well-prepared DMCA complaint that asserts copyright and the content is federally required to disappear?

Answer: Yes.

(IANAL, but I have researched it extensively to draft policy.)

<comment><USER6> I checked the statute. You're right about a DMCA notice / counternotice exchange essentially requiring a minimum of 10 days of the disputed content being offline. Thanks, I like learning things.

</comment></comment></comment></comment><comment><USER8> The title on the post is "Counterfeit Lugaru on Apple's App Store", which is slightly less inflammatory, and much more correct.

</comment><comment><USER9> Hang on, if the claim is that the source is under the GPL (and I'm not that convinced saying the characters are excluded is sufficient - a trademark violation would be more sensible) surely all they need to claim is a GPL violation (no source distribution) and cite the previous incompatibilities between the GPL and App Store.

As copyright holders they can later resubmit the game under a different license.

</comment><comment><USER10> I wish Apple had a 'flag application' button in the App Store to flag things that seem amiss and report them. If so, I'd have flagged this for being GPL software on the app store.

<comment><USER7> > If so, I'd have flagged this for being GPL software on the app store.

Which is probably why they _don't_ have a flag application button.

<comment><USER10> Perhaps, but it seems to be a pretty legit reason to pull something.

edit: instead of downvotes, i'd love a response to understand why someone should be allowed to put a GPL application on the app store and not distribute their code (and that you can't copy the application and send it to others, etc). Seems to be a pretty clear GPL violation.

</comment></comment></comment><comment><USER11> I wonder how many people visiting their site are going to take this opportunity to get the game at a discount... hopefully not many.

<comment><USER12> Apple's response when they decide to take it down will be the interesting part. We'll find out if there is a kill switch or blacklist in the mac app store.

<comment><USER13> not really. stuff gets taken down off the App Store all the time due to legal issues and obvious copyright infringement.

the apps get removed (you can't download them anymore), but anyone who has downloaded it can still use their copy.

<comment><USER12> <http://news.cnet.com/8301-13579_3-10013322-37.html>

Supposedly there is some sort of kill switch functionality in the iOS app store, and I haven't heard about copyright infringement to the level of taking someone else's game and redistributing it before. In my mind, the best case scenario is to refund everyone's money and take the game off the market, uninstalling from computers. The only backlash you receive is the press about the kill switch functionality and the whole "dude, where's my game" moments that people will have.

<comment><USER13> Oh, there's certainly a kill switch. Jobs admitted to it during an interview, but it hasn't been used. The closest App Store comparison is probably Abuse (source code released into public domain, <http://en.wikipedia.org/wiki/Abuse_(video_game)> ):

<http://appshopper.com/games/alien-abuse> (pulled from app store)

<http://appshopper.com/games/abuse-classic> (official version)

reason: [http://forums.toucharcade.com/showpost.php?p=426791&post...](http://forums.toucharcade.com/showpost.php?p=426791&postcount=238)

 _Long story short, Eurocenter did not have the right to use the sound effects, registered levels (levels 5 and up), or the Abuse trademark in their game "Alien Abuse"._

So very similar circumstances. And the original app was never killswitched.</comment></comment></comment></comment></comment>


Panasonic Lumix GF1 Field Test – 16 Days in the Himalayas - <AUTHOR> http://craigmod.com/journal/gf1-fieldtest/

<comment><USER2> This is from 2009, and the camera mentioned isn't sold anymore. Very nice design and photographs, though.

<comment><USER3> Yep. It's a 2009 article. I can vouch for the quality of the camera though. Mine's still going strong. :)</comment></comment>


Jam With Chrome - <AUTHOR> http://jamwithchrome.com/

<comment><USER2> According to <http://www.jamwithchrome.com/technology>

"The real time websocket relay system used to make collaboration with JAM possible was developed using the Go programming language."

And the web app is hosted on app engine. AFAIK though, you couldn't host the Go websocket component on app engine (even though GAE supports Go as a runtime) since GAE doesn't support persistent connections directly.

In any case, very very cool!

<comment><USER3> I think you missed the Channel API : <https://developers.google.com/appengine/docs/go/channel/>

(also available for Python and Java)

<comment><USER4> The Channel API doesn't currently use WebSockets. Instead it uses Comet techniques like forever frame and long polling.

[http://code.google.com/p/googleappengine/issues/detail?id=25...](http://code.google.com/p/googleappengine/issues/detail?id=2535)

</comment></comment></comment><comment><USER5> Lots of fun. Always wanted a live Internet jamming solution for a band. Now, if only it could work with real instruments plugged to the computer. But the network delays make it impossible. Waiting for the day when bits from Europe to the US won't take 100-150ms to travel. Not sure it's going to happen anytime soon, though.

Any 2 sounds played above 30ms apart start to be distinct to the human ears.

<comment><USER6> The speed of light is always going to be a limitation for these kinds of applications . I dont see how the latency can be reduced enough to make this close enough to a live jamming session . Considering your 30 ms threshold it takes light that much time to travel 10,000 kilometers . Could we perhaps use some of the predictive techniques that games like Counter strike use ?

<comment><USER7> Quantum entanglement, perhaps? It's supposed to transfer information without any speed of light limitation.

<comment><USER8> If we could get enough bits to work with quantum entanglement then sure. But regardless to get information out of a quantum entanglement you have to send a basis of measurement before you can decode the data so you are still bound by the speed of light.

<comment><AUTHOR> That's the best explanation I've read of why quantum tunnelling doesn't allow FTL information transfer. Thanks!

</comment></comment></comment></comment></comment><comment><USER9> Cute, novel, technically impressive from a web design perspective.

But does it have AISO low latency audio driver support? Lets not even get into the latencies websockets are going to create. Even if you set something like this up on a LAN, the latencies would still be too high for any truly professional musician.

Dont expect anything like this being used by any real musicians anytime soon, even minus the websockets collaborative part.

Still very cool though. But I still wait for a day when something like Rock Band or Guitar Hero actually has professional low latency audio that could seriously be used live on stage by a band with sub 10ms audio latencies.

If rockband and guitar hero cant even do that, I'm not holding my breath for chrome anytime soon, especially in a networked situation.

<comment><AUTHOR> Presumably the WebMIDI authors are thinking about latency?

<http://www.w3.org/TR/2012/WD-webmidi-20121025/>

<comment><USER10> Ah what I didn't know there was a WebMIDI draft... do any browsers plan to support this?

<comment><AUTHOR> Chris Wilson is an author of this and at Google so I guess Chrome at least will implement. No idea beyond that.

</comment></comment></comment></comment><comment><USER11> Does anyone know if they stream audio or just events to peers over Web Sockets?

Some tech notes from a pro-audio software developer:

\- All the samples are OGG ( [http://chrome-jam- static.commondatastorage.googleapis.com/xm...](http://chrome-jam- static.commondatastorage.googleapis.com/xml/PreSounds.xml) )

\- They're using some "DMAF" engine for the audio, though I can't figure out who made it: <http://www.jamwithchrome.com/js/compiled/dmaf_all.js>

It's pretty serious stuff from the looks of it - It's got a node graph with different DSP modules (envelope follower, delay, ADSR, distortion, LFO, chorus, compressor, phaser, equalizer, biquad filters), it plays MIDI files, and more.

It's all written in JavaScript too, and there's no way you'd write this just for one Chrome experiment. I don't see any outside party acknowledged on the website, but I'd guess that this DMAF JS audio engine is licensed from someone.

It's interesting to see what they've been able to do with the Web Audio API and JavaScript, but I think the Web Audio API is going to be forever limited to toys like this unfortunately. You just can't do real-time audio with a garbage collector waiting to pounce.

I developed a similar application for Chrome (which coincidentally had the codename "Jam"), but instead, it uses Native Client for audio instead of the Web Audio API. It's called SongStarter, and you can jam with it here: [https://chrome.google.com/webstore/detail/jbkilbgofafobojkif...](https://chrome.google.com/webstore/detail/jbkilbgofafobojkifhjflhnnbiojbjb)

(NaCl apps must be installed from the Chrome Web Store for the time being, otherwise they won't work. Google's choice...)

<comment><USER12> DMAF is our framework at www.dinahmoe.com. It stands for DinahMoe Audio Framework. I'm the one who's been doing the grunt work of the framework, so I'm quite familiar with it ;) We've decided to release the effects as open source at <https://github.com/Dinahmoe/tuna> , though it's not complete yet with all the effects.

<comment><USER11> Awesome, great job with it, and nice that you open sourced it!

How long have you been working on it for?

There's going to be loads of "big brand" companies looking for crazy audio doodads for their websites after this Jam thing. Probably lots of contract work to found be there... :)

<comment><USER12> Thanks :) Let's hope so.

It's been in the making since December, if I don't remember it wrong. I have to give credit to the rest of my team too, of course.

</comment></comment></comment></comment><comment><USER13> I've said it before and I'll say it again: someone really needs to build the "Google Web Fonts" of Web Audio API instruments/effects. If developers were able to include sampled/synthesized sounds as easily as dropping in a script tag, it would open up a whole world of possibilities for interactive music on the web.

<comment><USER14> I was just thinking this the other day. What form do you think this would take?

I have only a fuzzy understanding of how this works, but I was thinking you could run a bunch of .wav samples through Web Audio to get their wave shapes ... save them as arrays, and then synthesize sounds from a single js file? (Rather than lugging around the .wav files themselves).

If this is possible, it would be awesome.

<comment><USER13> Well, I was thinking more along the lines of providing a service that takes care of all the note-sample mapping for you. You could either specify instruments/effects that you want via script tag url params, or perhaps using some kind of loading library (Google Web Fonts offers both of these methods). The bottom line is that you would be provided with patchable Instrument and Effect objects that expose a simple interface for triggering/releasing notes and modifying relevant parameters.

<comment><USER15> There is a complementary discussion to this happening at <https://github.com/h5bp/lazyweb-requests/issues/82>

<comment><USER13> a complementary discussion which, it turns out, I started! ah ha!

</comment></comment></comment></comment></comment><comment><USER16> <http://www.jamwithchrome.com/technology>

Go backend using App Engine.. Good to see Google pushing it.

</comment><comment><USER17> <http://www.multiplayerpiano.com/> is similar. It only supports the piano instrument, but it has a public lobby where you can play with other visitors to the site, as well as private rooms.

</comment><comment><USER18> ... as long as you're not on chrome mobile, which is 4 versions behind.

<comment><USER19> Make that 5. Desktop Chrome is v23 now. This would be great as an app for Android tablets, though - something like an alternative to Apple's Garage Band.

It seems yo can add this as an extension to Chrome, too:

[https://chrome.google.com/webstore/detail/jam-with- chrome/bg...](https://chrome.google.com/webstore/detail/jam-with- chrome/bggjdpbfjakfkacljidachigalghbnpk)

It seems to say that I can use the QWERTY keys to play the guitar, and while the buttons are moving on the screen, the chords aren't. Is that a bug or am I doing something wrong? The sounds seem to work only when I used the auto mode.

<comment><USER20> When you're in "Easy" mode, the keys (or in your case frets) don't actually do what they should in reality; They're just used to define generally what range the autoplay pattern gets centered upon (the actual notes played are governed by the selected chord). It's kind of disappointing, really; It should let you play real notes in conjunction with the patterns in my opinion.

The real bug, though, is that the "key" setting at the top of the UI that's supposed to update the available set of chords is completely wonky, and rarely does what it's supposed to (what, you wanted B? Let's go with A instead. You chose major? Minor it is!)

</comment></comment></comment><comment><USER21> So this is kind of odd... Nothing loaded when I first opened the page. I opened developer tools and had a javascript error "Failed to load resource <http://connect.facebook.net/en_US/all.js> . Well, I keep all facebook widgets blocked with Ghostery and disabling it allowed the website to load.

Seems kind of strange. I mean if FB goes down or moves the location of that js file or something, the whole jamwithchrome site won't work?

</comment><comment><USER22> What is missing from firefox that makes it incompatible with this?

<comment><USER23> I think Firefox and Chrome have different (experimental, advanced) audio interfaces right now.

I'm not really sure about the differing capabilities, or what standardization of either looks like right now. But I _think_ Mozilla's api is more low level, so it might be possible to create a compatibility shim on top of it?

<comment><AUTHOR> Mozilla will be adopting the WebAudio API from Chrome and have deprecated their own (lower-level) API. Work hasn't started yet though.

<comment><USER24> No, work has in fact started,

<https://bugzilla.mozilla.org/show_bug.cgi?id=WebAudio>

<comment><AUTHOR> Oops, hadn't realised that was a metabug, just saw that it didn't have any attached patches. Mea culpa.

</comment></comment></comment></comment></comment><comment><USER14> This is really cool. Nice going. I'm amazed to see how many people have been working on similar things. I took a shot at this a while ago (<http://soundtype.com>) but I was stuck using Java for MIDI. Really looking forward to the MIDI spec for the Web Audio API.

Being that this is HN many of you might have seen this already, but there's an exciting Google IO talk from Chris Wilson about Web Audio: <http://www.youtube.com/watch?v=hFsCG7v9Y4c>

And see the corresponding slide deck for code: <http://webaudio- io2012.appspot.com/#1>

</comment><comment><USER25> Online music players like this are pretty cool, but I find it really hard to actually produce a meaningful tune while holding down keyboard and dragging mouse around.

Oh well, maybe I just need to practice more!

<comment><USER26> You can use your keyboard too.

</comment></comment><comment><USER27> Also check out <http://www.instajams.com>

My best friend and I built this in a few months and we're really proud of it. It's still very early but we're adding new features all the time.

It doesn't have the graphic design and branding of jamwithchrome, but you can start creating music really quickly.

Also, if you sign up for free, you can create and loop clips and jam with yourself if you like.

Give it a try and let us know what you think.

Best

</comment><comment><USER28> This is very cool, but would love to see an easier way to strum the string instruments. It is hard to get a good rhythm going while holding the button down and fighting cursor drift.

</comment><comment><USER29> "There is something wrong with the plumbing. Check network connections."

Not sure where to go from here, since I certainly have a connection.

<comment><USER30> You are probably blocking some ports it expects to communicate on. WiFi or Ethernet?

</comment></comment><comment><USER31> <http://www.dinahmoe.com/?projects=jam-with-chrome>

[http://www.html5rocks.com/en/tutorials/casestudies/jamwithch...](http://www.html5rocks.com/en/tutorials/casestudies/jamwithchrome- audio/)

</comment><comment><USER32> Just finished my jam session... was awesome. Crashed my chrome but I think that must be something about the memory in my mac. But amazing app... have a lot of fun :)

<comment><USER33> Think of it like smashing your guitar or something else equally rock 'n roll :)

</comment></comment><comment><USER34> Crashes under Chrome 23.0.1271.64 (xubuntu 12.10). :/

<comment><USER35> 23.0.1271.64 on 64-bit Kubuntu 12.04 works fine, fwiw.

</comment></comment><comment><USER36> Would be interesting to know what it is about the page that is causing Chrome v23 on Ubuntu to "Aw, Snap!" so reliably.

</comment><comment><USER37> Not working for me on Version 23.0.1271.64 on Ubuntu. I get an Aw, Snap after I select my instrument.

</comment><comment><USER38> I'll try this after they fix Chrome to stop kernel-crashing my Macbook Pro 2012.

</comment><comment><USER39> Crashes my chrome page. Lame.

<comment><USER40> Works fine for me and is pretty awesome. Upgrade Chrome or your computer

<comment><USER41> Crashes for me. Chrome Version 22.0.1229.94 m. There are no upgrades for chrome. What should I upgrade on my computer?

<comment><USER42> Current stable version is 23.

</comment></comment></comment></comment><comment><USER43> Join me

<http://goo.gl/LqpBJ>

</comment><comment><USER44> Nice! All it needs is MIDI, which is already on the way in HTML5.

</comment><comment><USER45> crashed chrome for me =( Version 22.0.1229.94 (on Debian testing)

</comment><comment><USER46> What would a million people all jamming together sound like?

</comment><comment><USER47> Blank screen for me.

</comment><comment><USER48> Productivity = lost

</comment><comment><USER49> the amount of work to get this working is incredble

</comment><comment><USER50> If you use it, disable the vimium extension.

<comment><USER33> Disabling Vimium is a bit overkill, you can press "i" to go into insert mode and it'll let you do as you please...if you use it more often, though, it's best to blacklist it.

I didn't know about the insert mode thing for a long time, but when I figured it out it was a "duh" moment :)

</comment></comment><comment><USER51> scaringly fun, just lost 15 minutes here :)

</comment><comment><USER52> Judy G

</comment><comment><USER53> awesome....</comment>