Ask HN: How to be fluent in functional language speak? - <AUTHOR> When I read academic articles or blog posts written by functional programmers it feels alien to me because of the terms used in their writing. I am not just talking about monads, monoids etc, but the general programming terminology itself is different to what I regularly hear and read as imperative OO programmer. For e.g. this sentence "abstraction over type constructors"; whenever programmers from C++, Java etc world will read that they are sure to say, "eh?!?" and fall off their chair.<p>So how does a programmer from non-functional world become fluent in understanding sentence such as "abstraction over type constructors"? <comment><USER3> "abstraction over type constructors" isn't very meaningful without more context anyway, but they're probably referring to something like the following:

non-abstracted:

        map :: (a -> b) -> List a -> List b

abstracted:

        map :: Functor f => (a -> b) -> f a -> f b

"List" is a type constructor (it takes a type and returns a type), but we can write a "map" function that works over more types than just List - <USER2> example, Maps and Options and so on (aka "Functors" in Haskell parlance). We've "abstracted (the function map) over the type constructor (of the data structure being mapped over)".

To answer your more general question, if you just learn functional programming on a language with a powerful type system (Haskell is probably the most germane example) you will learn at least some of these terms. Most of them turn out not to be very deep, just hard to explain (for reasons unclear to those who understand them), but still very useful.

<comment><USER4> > We've "abstracted (the function map) over the type constructor (of the data > structure being mapped over)".

Then why didn't they just call those types "Mappables"?

<comment><USER5> I think this is a great question because it tends to come up a lot.

What do you call the following common operations?

      - 1 + 0
      - 1 * 1
      - "string" ++ ""
      - [1, 2, 3] ++ []

As far as I know there is no term for this grouping of operations outside of functional programming languages which use category theory.

We call it a "monoid" based on the following precise definition:

> In abstract algebra, a branch of mathematics, a monoid is an algebraic > structure with a single associative binary operation and an identity > element[1].

I used the "identity element" specifically in my examples above since they tend to be a good way to grasp what is going on.

It turns out a "functor" has more properties than just being "mappable", which is why we like using the more precise term in our literature. However, it's still a decent intuition if you aren't familiar with the concept.

For example, in the parent comment the 'f' in the second line of code shows that it is _some kind of structure_ that adheres to a Functor, and also infers that this structure can also be mapped over. This is a nice property because without caring about the _implementation_ , we can still do functor-specific operations over abstract structures.

[1] [https://en.wikipedia.org/wiki/Monoid](https://en.wikipedia.org/wiki/Monoid)

<comment><USER6> "binary operators with an identity value"

<comment><USER7> the binary operation should also be associative (e.g. subtraction is no good)

</comment></comment></comment></comment></comment><comment><USER8> Practice programming in a functional language. They enforce a lot of restrictions that you won't be used to, and in overcoming these restrictions, you'll begin to learn and understand the reason for the jargon.

It's really hard to explain "abstraction over type constructors" in a pithy manner despite being a relatively simple statement because the obvious follow- up is "but why?" And the answer to that question isn't going to satisfy you without an understanding of the functional programming environment.

It's exactly like when novice programmers get thrown into Java land in CS101 and you have to tell the to just ignore the whole class, public, private, static, etc jargon. They need to gain experience programming in that environment to really appreciate those concepts.

</comment><comment><USER9> Simply, read this:

[https://fsharpforfunandprofit.com/fppatterns/](https://fsharpforfunandprofit.com/fppatterns/)

Then:

[https://fsharpforfunandprofit.com/rop/](https://fsharpforfunandprofit.com/rop/)

Then if wanna go round:

[https://fsharpforfunandprofit.com/series/thinking- functional...](https://fsharpforfunandprofit.com/series/thinking- functionally.html)

Ok, almost all that site. is truly good.

<comment><USER10> Scott Wlaschin (the author of that site) does an amazing job of explaining functional programming concepts, and I highly recommend both his site and his book, "Domain Modeling Made Functional". But he does usually try to _avoid_ words like "monad" and "functor", so you might not pick up fluency in the mathematically-inspired vocabulary from this particular resource.

</comment></comment><comment><USER11> I think the first step here is to put your expectations into perspective. Functional programming also is a range of complexity. If you're not used to functional programming and try to read articles targeted at the high-end you'll naturally struggle to understand them.

I still remember "not getting" OO in university in my first lecture. I had programmed BASIC, C, Pascal, PHP before. And if someone would have tried to explain me the idea by means of the visitor pattern, it would surely have made me say "eh?!?" too. So allow yourself to start slowly.

I'm also still dabbling in functional programming - at least that's what it feels like reading about monoids etc - but by actually using functional programming languages in my more serious spare time projects I feel I get a better and better understanding. And "those" articles start to speak more to me.

</comment><comment><USER12> You're not alone. Even functional programmers struggle to read those papers. I found that in the functional programming world there's a lot of concepts being thrown around with different names.

I think your best option is to directly contact authors or very good educators and ask them exactly what they mean.

</comment><comment><USER13> First, you probably don't need to read academic articles to learn about functional programming. There's really nothing magical or complicated with functional programming. For instance, Scheme or OCaml are routinely used as beginner programming languages in schools around the world.

You can start with the basic concepts and eventually build your way up to more abstract constructs when you realize you need them. But even there, you don't need to know the academic terminology (or if you do, it'll make more sense when you get familiar with the language).

I frequently use monads and functors, yet I don't know much about category theory (and the little I know doesn't make me a better programmer).

<comment><USER3> Not sure about Scheme, but OCaml's type system is not powerful/expressive enough that (to use the given example) abstracting over type constructors is likely to ever come up. (No HKTs in OCaml.) Also, OCaml uses a naming scheme for certain things that I haven't seen used elsewhere - e.g. what OCaml calls a "Functor" is a parameterized module, not closely related to Functors in other languages that use that abstraction. I suspect this is a result of the French/English language divide in the initial development of OCaml vs all other major functional languages.

<comment><USER14> OCaml functors come from Standard ML, which predates Haskell. And you can definitely use them to implement HKTs — they are comparable in expressiveness to single-parameter typeclasses.

<comment><USER3> I use OCaml at work ~every day, and HKTs (to the extent they can be expressed at all, using HOMs) are so unwieldy that I have never run across them in production code. In Haskell, they are both easy and routine. So I'm approximating this with "no HKTs in OCaml".

<comment><USER14> HKTs indeed aren't a common pattern in OCaml, but first-class modules and similar patterns are common enough in Core. Your statement was that the type system was not powerful enough to express them at all. Whether or not it's practical is a bit different :)

You also said that their use of "functor" was probably the result of being French vs English, when I pointed out that in fact it came from Standard ML, which is a British design. Moreover, the creators of Haskell originally built typeclasses as an extension to Standard ML (1980s), and Functor was added in the same version of Haskell that Monad was (1.3, roughly 1998).

The connection between ML functors (specifically the interface/signature) and typeclasses in Haskell is relatively clear, if you understand how they both work. I don't disagree that typeclasses are more general, but modules have their appeal as well. I'm pretty excited to see where Backpack ends up in Haskell, personally.

<comment><USER3> I definitely sufficiently hedged my original claim:

> OCaml's type system is not powerful/expressive enough that (to use the given > example) abstracting over type constructors is likely to ever come up.

And I stand by that. It's not likely to ever come up, even if it's possible to kludge it.

You're right about the name though - it seems like the anomalous use of "functor" predates francophone intervention.

<comment><USER14> It's weird to call it anomalous ML came first in the programming sphere.

What you said is that it's not powerful or expressive enough, but my impression was that they were both expressible in terms of System Fω, an understanding I would like to correct if it's wrong.

<comment><USER3> > It's weird to call it anomalous ML came first in the programming sphere.

Eilenberg and Lane introduced functors (in the sense more or less used by Haskell) in the 40s.

> my impression was that they were both expressible in terms of System Fω

This is not correct anymore - Fω is insufficient to describe GADTs. You need coercions and equality constraints as well.

It's also approximately as useful a claim as "the languages are equally powerful because they're both Turing complete".

I'm referring to practicability, not theoretical possibility (and I've clarified as much several times now).

<comment><USER14> >Eilenberg and Lane introduced functors (in the sense more or less used by Haskell) in the 40s.

Yes.

>This is not correct anymore - Fω is insufficient to describe GADTs. You need coercions and equality constraints as well.

Of course, OCaml has GADTs these days. I suppose neither of them are really Fω anymore, then.

>It's also approximately as useful a claim as "the languages are equally powerful because they're both Turing complete".

Agree to disagree. I think when discussing how powerful a language is, a rigorous notion like Turing completeness or position on the lambda cube is still significant, even if it's not the most immediately visible.

>I'm referring to practicability, not theoretical possibility (and I've clarified as much several times now).

Fair enough, I'll chalk this up to a misunderstanding.

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER15> It's not the jargon of functional programming, it's the jargon of type theory and PL design. So maybe start there?

</comment><comment><USER16> As with so many things in life, a lot of it boils down to practice.

Are you just trying to read academic articles and blog posts? Have you tried working in one or more of the languages? Beyond "toy problems" to trying to solve larger problems?

The more you work in a language, the more you might start to understand the needs that underlie things like category theory (the mathematics of monoids, semigroups, monads, etc) and where other higher level abstractions start to play in how you want/need to write software.

There's also places to practice even in C++, Java, etc. A lot of functional programming is making its way "stealth" into even the most imperative OO languages. Are you handy with your languages map/filter/reduce libraries around iterables? Have you tried pushing that deeper towards other monads such as query transformation (Linq) or time (async/await, ReactiveX)? Have you thought about how those work under the hood? (Explored what a iterable generator or an async/await decompile to?) Have you started yet to think in terms of high level "lambdas", places where functions themselves can be reused by other objects/functions? (Beyond "callbacks" towards thinking of functions themselves as lego bricks to build with.)

There's also middle ground languages such as F# or Clojure that you can use side-by-side (in some circumstances) C# or Java (respectively) code where maybe you can't work 100% in a functional language on a project, but you can get a compromise mix.

So much of understanding the "lingo" is recognizing the patterns and/or problems to which they refer, and a lot of the easiest way you will pick up patterns and see recurring patterns is practice.

</comment><comment><USER17> I got comfortable with Lisp using [http://www.4clojure.com/](http://www.4clojure.com/)

Learning through games like this is a big help because they provide: 1\. clear and approachable goals 2\. clear feedback on whether you've achieved the goals

Maybe Clojure isn't what you're looking for but maybe there's a similar service for a language you'd like to learn.

</comment><comment><USER18> If you are coming from imperative land (more specifically C++) then nothing beats articles and videos by Dr. Bartosz Milewski:

[https://bartoszmilewski.com/2014/10/28/category-theory- for-p...](https://bartoszmilewski.com/2014/10/28/category-theory-for- programmers-the-preface)

[https://www.youtube.com/watch?v=I8LbkfSSR58&list=PLbgaMIhjbm...](https://www.youtube.com/watch?v=I8LbkfSSR58&list=PLbgaMIhjbmEnaH_LTkxLI7FMa2HsnawM_)

[https://www.youtube.com/playlist?list=PLbgaMIhjbmElia1eCEZNv...](https://www.youtube.com/playlist?list=PLbgaMIhjbmElia1eCEZNvsVscFef9m0dm)

[https://www.youtube.com/playlist?list=PLbgaMIhjbmEn64WVX4B08...](https://www.youtube.com/playlist?list=PLbgaMIhjbmEn64WVX4B08B4h2rOtueWIL)

</comment><comment><USER19> I don't think this is different in OOP literature, where you may read something like "abstract factory pattern", you just need to get familiar with the terminology. I would start reading Pierce's _Types and Programming Languages_ and then any book on Haskell (you may also want to reinforce your abstract algebra :)

</comment><comment><USER20> I never use those terms and main programming goto is clojure.

"abstraction over type constructors" might have to do with typing and not related to functional programming.

<comment><USER21> You run the risk of being lynched by the Haskell mob, with talk like that. But I agree, in principle.

The hardcore "sound types" crowd believes that anybody using dynamic types is doomed.

I must not have the same problems they do.

First class functions; closures; higher order functions; partial function application, seasoned with the occasional variadic vs fixed arity function, and I'm good.

One can learn the other 95% of the jargon to deal with 5% of the problems later.

<comment><USER22> > The hardcore "sound types" crowd believes that anybody using dynamic types > is doomed.

What they believe is that "dynamic types" is a misnomer, and if you think your program is checking dynamic types, it is in fact doing runtime pattern matching over a variant record. There's nothing wrong with pattern matching and variant records; but conflating them with types is just nutty, and using them pervasively as part of the ordinary flow of code is no different than programming in old-style VB.

<comment><USER14> I don't think many people programming in dynamic languages would die on that hill. Avoiding types is kind of the allure, I think?

<comment><USER5> At the expense of having to write more tests that a type system could have solved at compile time, and likely catch more runtime logic bugs as well.

For the record I am a convert. Types have made my developer life much happier, especially working with unfamiliar code across multiple projects/teams. When you treat your builds as long term proofs your confidence level increases dramatically.

<comment><USER14> I don't disagree :)

</comment></comment></comment></comment></comment></comment><comment><USER23> I found it equally tough because while there are a lot of resources to cover the basics and get you coding in Haskell there isn't much to bridge the middle ground from there to the level the deep enthusiasts and experts are at. All I can say is keep trying and reach our for help on IRC channels or at a local functional programming meetup (and by local these days you could remote in to any meetup you like!). They'll be people happy to help.

It's been a while since I've dabbled with Haskell but I believe type constructors take a type and return a type (like List takes Int and returns List Int) so an abstraction over them might be an m where say m is a monad and it takes an a and gives you m a. m is an abstraction because it could be anything. A List, or Either, or State etc.

<comment><USER24> > type constructors take a type and return a type

Ordinary constructors, which everyone here is familiar with, construct values. They may take some arguments, which are themselves values.

A type constructor constructs types. It may take some arguments, which are themselves types. List is a great example of a type constructor with one argument. `Bool` is a type, and arguably a type constructor with no arguments. `Either` is a type constructor with two arguments.

In C++, `Pair` is a type constructor with two arguments; although there are more constraints on how you can use it (or at least were last time I delved deep in C++).

An example of "abstraction over type constructors" would be something that lets you pass in a type constructor as an argument, giving different behavior (whether parametric or ad-hoc - sorry, more jargon...) depending on what you pick.

</comment></comment><comment><USER25> Collect the definitions that you are learning over time. Put them in Anki as multidirection cloze deletions. Then, just do your Anki deck each day.

You will find that your fluency in almost any subject is improved with this practice.

</comment><comment><USER26> Question to all the functional programming experts: When OOP got introduced people started building all these elaborate object hierarchies and design patterns only to find out after a while that simpler is better and most features should be used rarely or never.

Is there also a risk with FP too that people fall a little too much in love with "elegant" code only to find out later that maybe simpler is better? Reading some people writing about FP I feel there is some risk of people doing this.

<comment><USER14> Generally in FP, "elegant" == simpler.

<comment><USER27> On that, I have seen lot of TypeFunctorMapMutatorKeywordsBeingImported to shorten the code and make it elegant...of course from the standard library or modules.

When you could have written it yourself with one or two extra lines. Why? Is it simpler? Or is it unnecessarily abstracted?

<comment><USER28> 1\. It's code reuse. Don't rewrite code that's already written.

2\. It's harder to understand. "Why didn't this use the standard library function? Is it doing something different? It doesn't look like it, am I missing something?"

<comment><USER14> It's definitely not _always_ just about code reuse, particularly when you start really stacking GHC pragmas and such.

</comment></comment></comment></comment></comment><comment><USER29> Try a textbook? e.g. Types and Programming Languages by Benjamin C. Pierce.

<comment><USER30> I agree that TaPL is an excellent book, but I did not find it useful in explaining functional programming idioms. (It does do a great job of explaining typed lambda calculus, however.)

</comment></comment><comment><USER31> Most of the jargon denotes straightforward definitions. Pick the top-most frequent three terms, e.g. monad, monoid, applicative, write down the definition + a small example on a card, lather rinse repeat a few times and you're golden.

Edit. For example, let's take 'catamorphism'. Read the Wikipedia entry [0] and it's a seemingly never ending jungle of more and more abstract terms. Homomorphism, initial algebra, F-algebra, endomporphism. This easy, let's see what an F-algebra is [1] and we'll be on our way soon. "If C is a category, and F: C → C is an endofunctor of C, then an F-algebra is a tuple (A, α), where A is an object of C and α is a C-morphism F(A) → A.". Oh my God, this is hopeless.

Or, find a good description, with examples [2]. A 'catamorphism' card, abbreviated from [2]:

Catamorphism

A function that "collapses" a recursive type into a new value based on its structure. Visitor pattern.

Define a sum type Gift:

        type Book = {title: string; price: decimal}

        type Gift =
            | Book of Book
            | Boxed of Gift

Define a 'description' function over Gift:

        let rec description gift =
            match gift with
            | Book book ->
                sprintf "'%s'" book.title
            | Boxed innerGift ->
                sprintf "%s in a box" (description innerGift)

Parametrize the function, creating a 'catamorphism':

        let rec cataGift fBook fBox gift =
            match gift with
            | Book book ->
                fBook book
            | Boxed innerGift ->
                let innerGiftResult = cataGift fBook fBox innerGift
                fBox innerGiftResult

Refactor your 'description' function to use a 'catamorphism':

        let descriptionUsingCata gift =
            let fBook (book:Book) =
                sprintf "'%s'" book.title
            let fBox innerText =
                sprintf "%s in a box" innerText
            // call the catamorphism
            cataGift fBook fBox gift

[0] [https://en.wikipedia.org/wiki/Catamorphism](https://en.wikipedia.org/wiki/Catamorphism)

[1] [https://en.wikipedia.org/wiki/F-algebra](https://en.wikipedia.org/wiki/F-algebra)

[2] [https://fsharpforfunandprofit.com/posts/recursive-types- and-...](https://fsharpforfunandprofit.com/posts/recursive-types-and- folds/#catamorphisms)

<comment><USER22> > Read the Wikipedia entry [0] and it's a seemingly never ending jungle of > more and more abstract terms.

Yup, category theory is often called "general abstract nonsense" precisely because it manages to talk about many disparate parts of math (or programming!) in a way that purposely avoids any reference to the specific. To usefully interpret the above, you _specifically_ need to know that your domain often uses the category ( _C_ ) of _types_ (as _objects_ ) and _functions_ (as _morphisms_ ), and that this category features certain generic types (such as Option, List, Array etc.) as _endofunctors_ \- and then literally plug all of those into the definition and work out the result.

It's exactly the difference between (in an elementary context) a word problem, vs. the general theory of equations of type foo which could be used to solve any number of word problems - except replicated at a higher level.

<comment><USER31> I like the way you frame CT. Never got too deep down this rabbit hole, the terminology is just too atrocius. I wonder though how useful it is in practice. It is easier for me to take a formula and generalize it among one dimension at a time as the needs arise, see the catamorphism example above. As opposed to correctly divine 5-10-15 very specific concretizations of an uber- abstract scheme to arrive to the same result. Echoes of premature abstraction.

Perhaps the world lacks CT for dummies. Teach it in primary school. New Math was not aggressive enough ;)

</comment></comment></comment><comment><USER32> In Java terms, a "type constructor" would be a generic class like, say, `ArrayList<T>`.

A constructor can be viewed as a function that takes values for the fields of a datatype and gives a value of the datatype in return. Not all functions are constructors, but some are.

At the type level, if we squint a little, "Maybe" or "List" behave a bit like constructors. They take types like "Int" or "Bool" as parameters, and give types like "Maybe Int" and "List Bool" in return. Not all type-level "functions" are type constructors (for example, in Haskell type families are not type constructors) but some are.

</comment><comment><USER33> I also dislike unnecessary use of programming jargon. A type constructor is all the possible ways to make a value of that type.

For example:

      type answer = | Yes | No | Maybe

The type is 'answer'. The constructors are Yes, No, and Maybe (these are actually called type variants but now we're getting into jargon). I presume an 'abstraction over type constructors' means you want to generalize that type, so you can use the constructors to produce an abstract type that works with any type but I've never heard that specific term.

<comment><USER14> This is wrong, those variants are value constructors. The type constructor there is "answer," there's only one of them.

<comment><USER33> So type constructors take types as their parameters and return new types you're saying, whereas the variant type in my example, the values are the constructors that make up the value of Type Answer

<comment><USER34> That's right. Type constructors are related to generics. For example if you have a generic type `List<A>` you could think of `List` as a type constructor.

In most languages, however, that's not a construct you can do much of anything with.

</comment></comment></comment></comment><comment><USER35> Keep trying to understand, asking questions, trying stuff first hand and eventually it'll come! The "Hask anything" sticky in /r/haskell is a friendly & pseudonymous way to ask questions too.

One thing I've noticed working in Haskell: Everyone is an expert in different things. Very rarely do I meet a Haskeller whose knowledge or interests subsumes another. That's part of the fun. Everybody doesn't know some terms!

</comment><comment><USER36> I got comfortable with Lisp/Scheme using DrRacket. It is actually very helpful for beginners. I think you will benefit by learning functional programming this way, scheme is very simple and effective.

[https://racket-lang.org/](https://racket-lang.org/)

</comment><comment><USER37> Here's a reference you may find useful

John A De Goes - A Glossary of Functional Programming

[http://degoes.net/articles/fp-glossary](http://degoes.net/articles/fp- glossary)

</comment><comment><USER38> I had the same problem and decided to begin with fundamentals. I read "types and programming languages" by Benjamin C. Pierce and then things started to make sense.

</comment><comment><USER39> I guess the answer is simply: just study funcional programming. 30 minutes into any basic haskell course (e.g. the wikibook, or real world haskell) and you would know what a type constructor is. I don't know, you can't expect to magically know things without studying them first? :) What you mean when you say "functional programming speak" is just common technical terms with a specific technical meaning. You wouldn't complain you don't understand the meaning of "Minkowsky metric" before learning relativity :p

</comment><comment><USER40> Learn Map, Filter, Reduce. Build a toy project with a functional language.

</comment><comment><USER41> I took a Haskell class in college for that

It did not help much.

</comment><comment><USER42> > So how does a programmer from non-functional world become fluent in > understanding sentence such as "abstraction over type constructors"?

We already have very primitive (and restrictive) imperative OO languages which are good at teaching the basics to new programmers. My observation is, FP lacks such gateway languages. Even the simplest FP-first language is intimidating.

So my answer to your question is, a good strategy to learn these can be carving out a relatively small portion from a language (i.e Haskell with only Algebraic Types and Pattern Matching) and working only on it for a period of time. Doing that doesn't teach terminology but exposes what Haskell is really obsessed about. For the curious, it is expressing type relationships as flexibly as numeric arithmetic we know from high-school.

Just like high-school arithmetic, several recurring patterns (often called formulas in Math classes) have their special names. Almost all programming languages are good at closely matching that syntax in their numeric expressions. It is unfortunately not the case for types though. In programming,

this functional type (pseudo code):

      A = (X + Y) | Z

tend to be expressed as:

      interface class A {

      }

      class A1 implements A {
        X x;
        Y y;
      }

      class A2 implements B {
        Z z;
      }

or as:

      union A {
        struct A1 {
          X x;
          Y y;
        } a1;

        struct A1 {
          Z;
        } a2;
      }

In both examples, it is longer to write the same "meaning" in OOP than FP, especially when there are abstract methods involved.

This difference in verbosity (aesthetically subjective) bugs an FP programmer more and more as they get used to their language. When that happens, people start naming things. Having an abstract type of `Collection` is no longer enough because we realize `Collection`, `Mappable`, `Traversable`, `Generator`, `Optional`, `Atomic`, `Pair` and `Tuple` all share the similarity of:

* wrapping a type,

* having a way to access the wrapped value(s),

* and the wish to support all operations the wrapped value supports without an unwrap, composable out of the box.

We call this pattern a name, the infamous "Functor" (incorrectly but who cares), and axiomize those assumptions formally in the target language, so that it is longer reimplemented again and again. The word "Functor" itself otherwise has no meaning, it is letter salad.

To learn those names effectively, you must be comfortable enough with the basics so that you get annoyed by the repetition and start researching new names as you stumble upon with new patterns.

In Haskell, "abstraction over type constructors" usually means (in OO terms) "declare a new generic interface and implement that in the abstract type so that you don't have to reimplement it non-genericly in the concrete type".

</comment><comment><USER10> > So how does a programmer from non-functional world become fluent in > understanding sentence such as "abstraction over type constructors"?

Incoming essay...

Pure functional programming is fundamentally about software components called "pure functions", or just "functions" for short. (I'm quoting the term because they're not the same as what are called functions in other languages. I'd call those other things "procedures" instead, but alas.) Other programming communities rally around components like "objects", and that's fine. The important thing is to pick something to break your system down into, and here, we're talking about "functions".

"Functions" are simpler kinds of components than objects or procedures: the ways in which they behave are much more limited, so they're easier to reason about. When a "function" is interacted with, it can't perform any side effects, so interacting with the "function" multiple times gives the same behavior every time. Procedures can manipulate global state, and objects can manipulate internal state, so reasoning about them takes more effort. You have to keep track of time: what happened before this interaction?

"Functions" have two interfaces: an input side and an output side. When a "function" receives a value on the input side, it will always emit a value on the output side. We can wire "functions" together by connecting the input of one to the output of another. The result is a system with a single free input side and a single free output side -- that is, it's also a "function". This makes it very easy to wire up lots of "functions".

Usually, a "function" has certain expectations of the input values that it receives, as well as some guarantees about the output values it emits. In a dynamically typed language, when those expectations are not met, a runtime error is emitted. This is fine -- it's just one way to handle failed expectations. But sometimes we can formalize those expectations statically, and let the compiler check up-front whether those expectations are met. This does add some complexity: you might not be able to wire up two "functions" if one can't satisfy the other's expectations. Statically-typed programmers have decided that they're willing to put up with that.

In a statically-typed world, the input and output interfaces of our "function" software components can be tagged with specifications. Functional languages are often judged by how expressive these specifications can be; a specification language like this is called a "type system". You can have type systems for components that are not "functions", but the rules of composition become more complex. (For "objects", class systems are quite popular.)

Most type systems allow you to break down an interface specification into smaller pieces, which themselves are valid specifications. That means we now have two kinds of components in our system: "functions", which exist at runtime, and types, which exist at compilation time. The rules for how types compose can be more complicated than those for "functions", but we're usually okay with that, as long as "functions" are kept simple.

Some type systems allow a value to satisfy multiple types. For example, class- based systems allow this via subtyping relations. Others might describe types as predicates (truth functions) on a pre-existing universe of values (e.g. TypeScript). Pure functional programming typically requires mutual exclusion: a value cannot be part of multiple types. We often say the the type _defines_ its values because of this.

The low bar for a static type system is "algebraic types". This means that we have two ways to compose types, conventionally called "product" and "sum". Most type systems have products, but sums are historically rarer. Values of a product type `X * Y` look like `(x, y)`, and we can pull out either element of the pair. Values of a sum type `X + Y` look like either `Left x` or `Right y`, and we can ask which one it is and do something different depending on the result.

Java and C++ do not have sum types. You can approximate their specifications to some extent using the Visitor pattern or discriminated unions, but the implementations in these languages are verbose, and unpleasant to read and write. Rust and Haskell do have sum types, so specifications of that nature are used much more readily.

We can generalize further. We can think of the product and sum of types as "type functions", or "type constructors", that take a pair of types as input and produce a type as output. Many type systems allow you to define your own "type functions". In Java, these are generic classes: "List<T>" is a type function from some type T to the type of lists containing that type. In C++, these are templates. But in most pure functional programming, static type functions look just like runtime value functions, since they behave just like them too. It's just a matter of when they're evaluated.

Once again, when you have functions, you often want to place demands on their inputs, and guarantees on their outputs. Type functions are no different. There are many possible ways to "type types", as it were, but a popular approach is by using "traits" or "typeclasses". Just as with types and values, a typeclass places requirements upon the types that inhabit it. (But a type can also satisfy multiple typeclasses.)

For instance, "Monoid" is a typeclass on types with two associated items: a "zero" value of that type, and a "concat" function that takes two values of the type and gives another value of that type. If you know that a type is a Monoid, then you know that these associated items are also available to you, regardless of what the actual type is. (For instance, you can write a "concatAll" function that iterates over a list of elements of a monoid and concatenates them together _regardless of what the monoid type actually is_.)

With typeclasses in mind, instead of taking a "list of X" or a "set of X", you might abstract over all such things as "collections of X". But you don't want to say what a collection is for every possible X. We need to _abstract over type constructors_. A "collection" is any type such that, given a type X, you get a type with certain associated items expected of all collections. Java approximates this with subtyping.

"Functor" is, in some ways, a generalization of "Collection". A type function that is a "Functor" is a type that, if you have a value of that type over Xs, and you have a function transforming Xs into Ys, then there must be a mechanism to get a value of that type over Ys instead. We call this mechanism "map", and it can be instantiated over any collection. Got a list of X and a function from X to Y? We've got a way to get a list of Y. Got a set of X and a function from X to Y? We've got a way to get a set of Y.

Because "set" and "list" are type constructors, we say that we are _abstracting over type constructors_ to get a single statement about all such things. "For every Functor F, if I have an F containing Xs and a function transforming Xs to Ys, then I can get an F containing Ys."

</comment><comment><USER43> Give up while you can. Immutable data classes and functional pipelines are great, everything else isn't worth it. Lots of people say FP is amazing but very few people use it in the real world because like you say, its unintelligible.

<comment><USER3> This comment is a textbook example of the Blub Paradox.

<comment><USER24> I had a very visceral experience of Blub in my formative years. I don't recall how old I was, certainly under 11. I was explaining to my father the many things I could do in LOGO, and he asked about arrays. LOGO supports arrays, of course, but it was beyond anything I'd dealt with. I remember that feeling of entirely not understanding why you'd want to bother with arrays instead of just making more variables.

<comment><USER3> I had a similar experience also at age 11 - I was learning C++ to solve my math homework problems. I heard about Python, tried it out, and went on IRC to ask how I could write "goto" statements in Python. I couldn't believe it when people told me they weren't necessary, and linked "Go To Considered Harmful"!

<comment><USER24> Oh man, some of my LOGO programs had so many gotos.</comment></comment></comment></comment></comment>


Toyota invests $500M in Uber - <AUTHOR> https://money.cnn.com/2018/08/27/technology/toyota-uber/index.html <comment><USER2> 200 comments yesterday [https://news.ycombinator.com/item?id=17853248](https://news.ycombinator.com/item?id=17853248)</comment>


SonarLint provides feedback on bugs and quality issues added into your code - <AUTHOR> http://www.sonarlint.org/ <comment><USER2> Repository for command line version: [https://github.com/SonarSource/sonarlint- cli](https://github.com/SonarSource/sonarlint-cli)</comment>


Next generation config mgmt - <AUTHOR> https://ttboj.wordpress.com/2016/01/18/next-generation-configuration-mgmt/ <comment><AUTHOR> This is a project which I've just announced! There's an irc channel #mgmtconfig on Freenode if anyone would like to come lurk, ask questions, or hack on the tool!

Thank you for reading!</comment>


Foursquare: Why It May Be the Next Twitter - <AUTHOR> http://mashable.com/2009/07/25/foursquare-app/ <comment><USER2> I like Foursquare - it's fun. But I see problems. For one, I can't see how it'll break out of its niche crowd. One of Twitter's is that it's simple and universally accessible, on the web or on the go with any device. Most of the folks I know outside tech circles wouldn't bother with a game. This presents a chicken/egg problem as the less of my friends are on there, the less inclined I feel to keep using it.

I like the direction they're taking it with getting local businesses involved. There's value in a frequent flyer points system for restaurants, etc. But simply 'checking in' without express ties to transactions probably won't cut it. Further, trying to extract fees from small restaurants and businesses is an expensive feat.

Hope they prove me wrong!

</comment><comment><USER3> Foursquare looks pretty awesome. If only they had an app for the Pre!

<comment><USER4> I'm sure they willif the pre's marketshare makes it worthwhile to do so. I just wish they had it for my Sony erircsson i810

</comment></comment><comment><USER5> Because it did so well when it was still Dodgeball.

Just make a better client and have it feel like a game instead of 'just another social network.' Brilliant.

Edit: And if I recall correctly, Dodgeball predated Twitter, which might be something to mull over in the context of their argument.

</comment><comment><USER6> Fan of the service, I think it has potential.

But once it become actually influential (free drinks!) how will they protect against spam? What's to stop me checking in a hundred times at a venue (or alternating 2, so I don't have to "re-check in") and becoming the mayor?

</comment><comment><USER7> OT, but you know you've arrived when someone else is supposed to be "the next you"

<comment><USER8> Now all they have to do is monetize before they become "the next myspace."

<comment><USER9> Myspace monetized pretty well, actually: profitable when they were bought out, and then really profitable thanks to the Google ad deal.

In fact, I'd bet that there was only a brief period during which more than a tiny minority of people expected them to make more money than they eventually made.

</comment></comment></comment><comment><USER10> While these "why ___ may be the next ____" articles might make startup CEOs feel good, I've never seen much correlation with actual success.

I don't think this game looks compelling at all. Twitter is a communication and promotion tool, this is a location-based game; it's completely different. I think Mashable is out of touch. I'm so confident this app will never be a mainstream success I'd probably bet actual money on it. I'm not saying no location based games will be popular - I think they will be amazingly so, but this is not it.

And why does this company persist in calling their apps after irrelevant ball games? First dodgeball, now foursquare. Annoying.

<comment><USER11> Bah! Humbug!

Seriously, this crotchety rant is the best you could come up with? You apparently have never played this game and your critique offers nothing whatsoever in the way of substance, either for your dismissal of the game in question, nor for your characterization of Mashable as out of touch. Seriously, there's not a single actual point in there anywhere. You could be 100% correct on both counts, but as it stands, your comment adds nothing to the discussion.

<comment><USER10> What kind of "actual point" would you have preferred to see?

Of course I haven't played this game. I don't need to to say that this puff piece is misguided, just like I don't need to play Mafia Wars on Facebook to be able to emphatically tell you that that's not going to be the next Twitter, either - although that would, if anything, be more likely.

Look, I don't mean to be negative, but I think this kind of app only appeals to a certain type of person and does not have the mass appeal to spread beyond that niche. Mashable is in that niche, so they don't see that not all that many outside it find much value in devoting real time and effort to becoming the virtual "mayor" of a coffee shop.</comment></comment></comment>


Ask HN: How do I find the right co-founder? - <AUTHOR>

I'm just graduating college this week. I have an idea that I'm ridiculously excited about. I'm already working on it full-time, and I can build and launch the product by myself without a co-founder.
That said, I realize that I need a co-founder for a variety of reasons. I've already raised money for a previous start-up of mine, and I know firsthand that the start-up grind is simply too hard to do it alone.
I have a very particular idea in mind for who I would want as a co-founder, but nobody I know meets all the criteria. I want somebody with intelligence, work ethic, and integrity, and with a healthy appetite for risk.
I feel like someone in their 40's who desperately wants to get married and is thinking about whether or not they want to settle. I understand the benefits of having a co=founder versus not, but I also realize there are huge risks in picking the wrong person.
What should I do? And where should I look? <comment><USER2> I recommend a contract type relationship for a couple weeks or month, something where you can actually see their work, how they work and if they are a good fit for you. Just arrange it so you own all IP if it doesn't work out.

As far as finding co-founders, you can hit up various Hackers & Founders meetups. If you're the technical type then finding user groups or whatever can be a good place too.

Startup Weekends can also be a good place to look, but don't be super pushy about it (or you'll just be like everyone else there).

Also, this is a great article on the topic: <http://venturehacks.com/articles/pick-cofounder>

</comment><comment><USER3> You should be looking for someone who shares your passion, whatever it may be - and what the business is based around. So look in relevant communities to your business.</comment>


Hoefler & Frere-Jones Launch Cloud Typography Service - <AUTHOR> http://www.typography.com/holding/cloud.html

<comment><USER2> The entry price: $99/yr for 250K pageviews per month.

Less than $10/mo for access to the H&FJ webfont library is a steal in my book.</comment>


Nokia Dreams Of Shipping 200 Million Windows Phones - <AUTHOR> http://www.businessinsider.com/nokia-windows-phone-transition-will-take-two-years-2011-3#ixzz1GL7CSE5O

<comment><USER2> I dream of sending 200 million rocket ships to Mars.

I find it hilariously stupid that they're risking their strong presence in China to go exclusive with MSFT. Why didn't they just go MSFT heavy and keep heavy on Symbian in china?

</comment><comment><USER3> When I think of best seller I think of the iPhone; I forget how many Symbian based phones are out there.</comment>


Former Executive Charged with Price Fixing in Online Marketplace Prosecution - <AUTHOR> http://www.fbi.gov/sanfrancisco/press-releases/2015/former-e-commerce-executive-charged-with-price-fixing-in-the-antitrust-divisions-first-online-marketplace-prosecution

<comment><AUTHOR> Basically, automated algorithms in Amazon's marketplace that price-matched every time he or another seller raised or lowered the price of a poster.

Be careful out there, clever coders... you just might be breaking the law.</comment>


A most bizarre and mysterious cocoon  - <AUTHOR> http://whyevolutionistrue.wordpress.com/2013/08/29/a-most-bizarre-and-mysterious-cocoon/ <comment><USER2> Nature never ceases to amaze me. If you want to see some of the weirdest, most fantastically odd things Evolution has produced (for example, dancing spiders with multi-colored 'capes' that pop up), I highly recommend this blog: [http://wtfevolution.tumblr.com](http://wtfevolution.tumblr.com)

<comment><USER3> Oh my god, he's Campbell-locking.

After all, he's got the quick movements with the stops in between, and he wears some pretty colorful locking outfit. Since I can't find any evidence for Campbell inheriting this behavior from the spider or the other way round, I say it co-evolved.

</comment></comment><comment><USER4> A quick search turns up Bucculatricidae as a good candidate.

Example cocoon: [http://bugguide.net/images/raw/Y0BQZSBQF0AQJ08KLSBQTK5KCK4K9...](http://bugguide.net/images/raw/Y0BQZSBQF0AQJ08KLSBQTK5KCK4K9KKKOKUQLSUQZSGKY0VQAK5KWK4QPK6Q6KKKA0UQA0ZK9KKKWK.jpg)

<comment><USER5> I thought the same, but they already discussed that in the comments [1] as the first serious contender, only to ultimately dismiss it as something else entirely.

[1] [http://whyevolutionistrue.wordpress.com/2013/08/29/a-most- bi...](http://whyevolutionistrue.wordpress.com/2013/08/29/a-most-bizarre-and- mysterious-cocoon/#comment-503279)

<comment><USER6> They came to the same conclusion in the original thread last week - [http://www.reddit.com/r/pics/comments/1lcb09/possible_new_sp...](http://www.reddit.com/r/pics/comments/1lcb09/possible_new_species_rbiology_and_whatsthisbug/cbxzp62?context=2)

</comment></comment></comment><comment><USER7> Another interesting cocoon, linked to from the comments: [http://blog.perunature.com/2013/06/the-incredible-urodid- mot...](http://blog.perunature.com/2013/06/the-incredible-urodid-moth- cocoon.html)

Instead of hiding, the caterpillar builds an open-air net-like structure which hangs by a thread from the bottom of a leaf. The video hypothesizes that the structure both protects the pupa from ants and allows rain to flow through it (both of which seem like critical features in the Amazonian rainforest).

Also, it looks really cool.

<comment><USER8> Alternative, admittedly uninformed hypothesis: the structure makes it lighter, which means the chord suspending it can be thinner, which makes it harder for ants to crawl down it.

<comment><USER9> More-so, it's lighter AND allows air to pass through it so it's more stable.

</comment></comment></comment><comment><USER10> Any search engine experts here? How do people try to find the answer to this question if they know nothing about the subject?

My approach is to bang in various words and do image searches, forcing some and not others, and then try similar words. [weird cocoon] or [weird egg sac peru] and then sometimes including a subject word. (Entomology).

Then I do a TinEye search, or a GoogleImage search to see if I can find other pages talkng about it.

This feels sub-optimal.

What's a better approach?

<comment><USER11> I'm not sure if you have much of a chance of finding the answer if you know nothing about the subject - unless someone else already blogged about it somewhere. I'm sure that many of the people that are confused about it in the comments actually do have a background in biology, and they're having a tough time.

<comment><USER12> There's another possibility. Because of where this was discovered, it's more than possible that it's a new species. There are plenty of undiscovered species in the tropics, especially in the _insecta_ class.

<comment><USER11> Absolutely. It's not a "the first person who can tell me what this is a picture of gets a prize" thing, it's an "I'm a biologist and I'm genuinely confused about what this is, please help" thing.

</comment></comment></comment></comment><comment><USER13> Looks like some form of [http://en.wikipedia.org/wiki/Sisyridae](http://en.wikipedia.org/wiki/Sisyridae)

</comment><comment><USER14> I believe it's a drunk hipster spider feeling all artsy.

[http://www.google.com/imgres?um=1&sa=N&hl=en&authuser=0&biw=...](http://www.google.com/imgres?um=1&sa=N&hl=en&authuser=0&biw=1356&bih=651&tbm=isch&tbnid=nxb8pxTaOa1PxM:&imgrefurl=http://images.wildammo.com/2011/06/29/hipster- spider-web- developers/&docid=SuoOKfYVScb6EM&imgurl=http://images.wildammo.com/wp- content/uploads/2011/06/hipster-spider-web- developers.png&w=420&h=280&ei=Sz8mUpm- NcjTsATp5YCICw&zoom=1&ved=1t:3588,r:1,s:0,i:84&iact=rc&page=1&tbnh=183&tbnw=275&start=0&ndsp=23&tx=161&ty=86)

</comment><comment><USER15> It looks remarkably like the top of a water droplet hitting a pool of water in slow motion.

<comment><USER16> My first thought was "Edgerton milk drop".

[http://www.agallery.com/Pages/photographers/edgerton.html](http://www.agallery.com/Pages/photographers/edgerton.html)

</comment></comment><comment><USER17> it looks like a little hut/house surrounded by a tall fence. What a fantastic thing!

<comment><USER18> I'm guessing that it evolved the fence to prevent crawling predators from feasting on the cocoon while the bug is pupating. That said, its a really interesting example.

The next time the guy is out in the jungle and sees one the thing to do is to take it home, put it in a jar, and wait to see what pops out. I learned about mosquito eggs that way, as a youth I thought they were tadpole eggs, put them in my jar and waited for frogs. Instead I got mosquito larvae and then a jar of dead mosquitos (I didn't take the top off once I recognized the larval form.)

<comment><USER17> Or maybe set up a camera to take pictures every couple of minutes. Sometimes removing these things from their environment may prevent them from hatching.

</comment></comment></comment><comment><USER19> Incredible. I looks the organism erected a fence to protect whatever it is in the center. If this turns out not to be a hoax it will be truly amazing. It is part of the " _Endless Forms_ " of life.

<comment><USER20> [http://bugguide.net/node/view/754227/bgimage](http://bugguide.net/node/view/754227/bgimage)

It might not be the only bug that believes fences make good neighbors.

FYI: I found out about that from [http://io9.com/we-have-absolutely-no-clue- what-built-this-cr...](http://io9.com/we-have-absolutely-no-clue-what-built- this-crazy-comple-1243871592)

</comment></comment><comment><USER21> Tell the truth. What would you say if the "fence" was electrified?

</comment><comment><USER22> Evolution be praised.

</comment><comment><USER23> A few months ago a friend told me he felt hn had jumped the shark. This frontpage discussion about a blog post about a reddit thread pretty much settles any debate there was to be had on that topic!

<comment><USER24> "I'll miss the sea, but a person needs new experiences. They jar something deep inside, allowing him to grow. Without change something sleeps inside us, and seldom awakens. The sleeper must awaken."</comment></comment>


Dominos UK (pizza) has a fake Verisign SSL Seal - <AUTHOR>

Spotted by a friend: http://twitter.com/Joolz/status/21776951960
Image is hosted at https://www.dominos.co.uk/assets/images/site/secure-payment.gif and even while looking at that image, your browser will confirm that the SSL certificate is supplied by COMODO CA Limited, not VeriSign.
Nice to see a big company either not understanding their own website or purposefully lying on it. <comment><USER2> Maybe they used to have a VeriSign certificate, but switched to Comodo and forgot to delete the old image from the assets folder?

<comment><AUTHOR> It's not just in their images folder, it's displayed prominently on their payments page

<comment><USER2> That's what I meant...there is probably a sysadmin somewhere responsible for updating SSL certs, and a separate person responsible for updating images.

</comment></comment></comment><comment><USER2> On an unrelated note, I saw on the menu that Texas BBQ® is a registered trademark in the UK?

</comment><comment><USER3> I'm assuming Comodo poached them from verisign and no one has told Dominos to take down the verisign logo.

Comodo probably blabbed about their cheaper (lesser known)certificates, but they really dont stand a chance against the brand recognition that the verisign logo carries with it.

It looks like Dominos made a bad decision.

Avoid the Noid. Avoid COMODO.</comment>


Spotify Crack Chrome App 2020 - <AUTHOR> https://github.com/sooxiaotong/spotify-crack-chrome-app <comment><USER2> Wow, the implementation is just a few lines of code [1]. I expected it would need to be much more complicated.

[1] [https://github.com/sooxiaotong/spotify-crack-chrome- app/blob...](https://github.com/sooxiaotong/spotify-crack-chrome- app/blob/master/js/background.js)</comment>


Ask HN: How can you proof that your website content has been plagirized? - <AUTHOR> http://www.reddit.com/r/AskReddit/comments/bhall/how_can_i_prove_that_content_has_been_plagiarized/

<comment><USER2> Proof, as in 100% proof ? Or prove ? And Plagiarized.

You are going to have to prove 'provenance'.

<http://en.wikipedia.org/wiki/Provenance>

This is a very complicated subject, the best thing you can do is to document very carefully the process of creation, time stamps and so on, and then to use those to challenge the people that cloned your content.

Mostly in the context of college, but useful stuff anyway:

<http://www.bobbyelliott.com/Plagiarism.htm>

</comment><comment><USER3> While that's a difficult question depending on your meaning, you can get some info at <http://copyscape.com>. I paid for some premium credits personally, allows you to automatically check every page of your website.

Edt: clickable link.

</comment><comment><AUTHOR> Will Copyscape show which content came first?</comment>


Google's E2Email Gmail Encryption Looks a Lot Like Vaporware - <AUTHOR> https://www.wired.com/2017/02/3-years-gmails-end-end-encryption-still-vapor/ <comment><USER2> A couple of questions would be, how would E2E impact fighting SPAM --and do end users see SPAM as more of a threat than they do a chance of state-based eavesdroppers and how would they "afford" gmail if they did not monetize it via the advertising and data-mining of their users' data?</comment>


Ruby 2.4.0-preview1 released - <AUTHOR> https://www.ruby-lang.org/en/news/2016/06/20/ruby-2-4-0-preview1-released/ <comment><USER2> I've spent the past couple weeks thinking about what framework I want to use to build static sites. I've primarily used Middleman, or Jekyll when working with collaborators (think of Middleman as Jekyll but with no restrictions -- i.e. You don't have to use Liquid and you can write plain old Ruby objects and include them as with a typical full-stack app).

I used to do Ruby because of Rails work...now I do my work exclusively in Python and Node. I thought it'd be worthwhile to move to a new framework just so I don't have to juggle so many languages on a daily basis. Lektor (Python) is exciting and I'll check it out as a way to build client sites...but it's not quite as flexible as Middleman (to be fair, Lektor is very new)...Pelican looks good as well...but for now, I think Middleman hits the perfect spot for speed of deployment and hackability (it recently extricated itself from sprockets so that you can incorporate webpack.js or whatever asset build system you like), even accounting for Middleman's and Ruby's slow speed of execution versus the hugely popular Hugo (static framework in Go)

The truth of it is, is that once you've picked up Ruby, nothing feels quite as nice as a scripting glue language. I haven't kept up much with updates to the language...all I know is that yesterday, I finally updated my Ruby environment manager (rbenv)...it had been 2 years...and changed my system Ruby to 2.3.1 (from 2.1.5)...I had to update a few version numbers for dependencies, but otherwise, all of my old projects worked with barely a hitch...and it took me no time to get into writing custom plugins for my next Middleman site.

It does seem that the excitement over Rails and Ruby has ebbed, if you look at Github stats and Stackoverflow's latest survey. I am curious to see where the language can go from here, or how it can make a strong niche for itself besides Rails. but of all the "old" languages that I sometimes have to come back to, Ruby has been the most welcoming.

<comment><USER3> > The truth of it is, is that once you've picked up Ruby, nothing feels quite > as nice as a scripting glue language.

I today agree. Ruby is amazing as a light scripting language - heck, I think it's pretty great as an all-around language, but quick glue scripts are where it really shines.

I wouldn't be sad to see it fade in popularity if it weren't for the fact that the language(s) and/or ecosystems eclipsing it are so, well, lame. For a profession that demands so much careful, reasoned thought software engineers as a whole can be incredibly irrational.

<comment><USER4> > the language(s) and/or ecosystems eclipsing it are so, well, lame. For a > profession that demands so much careful, reasoned thought software engineers > as a whole can be incredibly irrational.

How do you reconcile an unsupported "lame" without being "irrational"? Do you have technical reasons they're lame?

<comment><USER3> Haha, good point.

I don't have time to go into much depth right now, but basically the ascendent languages don't seem to offer many compelling technical advantages. For example, I've yet to hear a compelling reason why JS makes a better serverside language than Ruby for most use cases. To be fair, Node and some of the JS libraries for a long time offered advantages over the Ruby ecosystem for things like websockets (EventMachine used to swallow stack traces in a really annoying way). But that has more to do with the ecosystem than the languages themselves.

I think part of the problem had to do with how dominant Rails was/is in Ruby. I wish a framework that better catered to emerging app design trends had gotten traction in Rubyland in, say, 2012.

As for specific complaints about JS, well, it's a perfectly fine language, but I don't think it's an improvement in any way over Ruby. It has a number of quirks and compromises - prototype inheritance, basically no support for modules, clumsy typing, to name a few - which people have been patching over and working around in lots of different ways over the years. You end up with a forest of different solutions to things that wouldn't have been a problem in other languages. Now some fairly dramatic changes are being introduced, which is probably good, but it means the ecosystem is even more complicated. Working with the JS ecosystem feels like working with a poorly maintained legacy codebase - there are lots of places where people have come up with workarounds to things that shouldn't have been a problem in the first place; it makes you tired just thinking about all the mental energy spent solving all the little unnecessary problems.

</comment></comment></comment></comment><comment><USER5> nice, what's keeping [http://www.isrubyfastyet.com/](http://www.isrubyfastyet.com/) from updating the charts to > 2.2?

<comment><USER6> Check out RubyBench. [https://rubybench.org](https://rubybench.org)

<comment><USER5> yes, really nice. I see there is a Discourse benchmark script, each Rails/Ruby project (like for example GitLab) could benefit from having this benchmark run with each minor version increment.

</comment></comment></comment><comment><USER7> I am still surprised by this behavior change from 2.2.3 to 2.3.0 (and also present in 2.3.1 and 2.4.0):

      $ ./ruby -e "puts RUBY_DESCRIPTION ; rand(BasicObject.new)"
      ruby 2.3.0p0 (2015-12-25 revision 53290) [x86_64-darwin14]
      -e:1:in `rand': undefined method `begin' for #<BasicObject:0x007fe0be4cb548> (NoMethodError)
    	from -e:1:in `<main>'

In 2.2.3 you get this, which I'd expect:

      $ ./ruby -e "puts RUBY_DESCRIPTION ; rand(BasicObject.new)"
      ruby 2.2.3p173 (2015-08-18 revision 51636) [x86_64-darwin14]
      -e:1:in `rand': undefined method `respond_to?' for #<BasicObject:0x007fa2d719bf78> (NoMethodError)
    	from -e:1:in `<main>'

It's as if rb_obj_respond_to changed... I don't understand it.

<comment><USER8> I think you're looking in the wrong place, `BasicObject` has no `respond_to?` so you'd need to trace the `rand_random` execution to see what ends up calling `respond_to?` on your `BasicObject` instance. Poking through github I'm guessing it's `rb_funcallv_public` but I may be missing something(s).

<comment><USER7> But that's just it; I would have thought the NoMethodError would have been around the missing "respond_to?" \- like it was in 2.2.3 - not around a missing "begin".

<comment><USER9> Like @tvon, I'm not up to digging through the code, but I'd guess it's falling through to eventually make an unconditional call to [http://ruby- doc.org/core-2.3.0/Range.html#method-i-begin](http://ruby- doc.org/core-2.3.0/Range.html#method-i-begin).

<comment><USER7> That's exactly right; but that's happening because vm_respond_to is returning true on a nil method entry. It's a puzzler...

<comment><USER9> I assume you mean at [https://github.com/ruby/ruby/blob/v2_3_0/vm_method.c#L1915-L...](https://github.com/ruby/ruby/blob/v2_3_0/vm_method.c#L1915-L1919). Agreed it's weird that rb_respond_to will now return true for objects where respond_to is undefined. Though I guess I can see upsides to doing so, and it would require something pretty weird to result in "wrong" behavior.

<comment><USER7> Yup that's the code that I'm wondering about.

The case I ran into was in a Rails 4.1 app where ActiveSupport::Duration (which subclassed BasicObject) was used like this: "rand(10.minutes)". That raised an exception in 2.3.0 but worked fine in 2.2.3. The fix was simple - "rand(10.minutes.to_i)". But still, I don't understand it.

<comment><USER9> Heh...I also ran into an issue with ActiveSupport::Duration, though in my case when passed as the only argument to a method with a signature along the lines of `f(time = 30, [star][star]options)`, with the error involving #to_hash. Since newer versions of ActiveSupport fix it, I didn't look into it too careful (just called #to_i). I'm glad you did!

<comment><USER7> Ah ha! It was a Ruby bug... longer writeup here:

[http://thomasleecopeland.com/2016/06/26/basicobject-is-a- ran...](http://thomasleecopeland.com/2016/06/26/basicobject-is-a-range.html)

</comment></comment></comment></comment></comment></comment></comment></comment></comment><comment><USER10> As someone that really appreciates overlayed comparative graphs has anyone visualised some common benchmarks yet

*edit: interesting HN site bug, I hit edit to update some autocorrect mistakes and rather than updating my comment it added a fresh one - but not the second time. Interesting.

</comment><comment><USER11> That is fast, I barely started using 2.3.0 in my projects. Not following closely what is added but have impression that rate of change in ruby land is picked up significantly.

<comment><USER12> They're on a predictable cycle: minor version release every December 25. (so 2.4.0 final will be released December 25, 2016; which is why they're calling it "early" as the many features may need more testing)</comment></comment>


Hackintosh Mod Used an Actual Trash Can to Look Like Apple's New Mac Pro - <AUTHOR> http://nofilmschool.com/2014/01/hackintosh-apple-mac-pro-trash-can-mod-tonymacx86/

<comment><USER2> Burying as dupe of [https://news.ycombinator.com/item?id=7123364](https://news.ycombinator.com/item?id=7123364).

</comment><comment><USER3> The apple logo is clearly not kosher, but since nobody is selling these and the forum where the idea and pictures were originally planted chose not to be named, what can they do...</comment>


France: All your books are belong to us - <AUTHOR> http://www.theregister.co.uk/2012/02/29/france_authors_rights_compulsory_acquisition/

<comment><USER2> I'm not clear on what's supposed to be so bad about this law.

The article fails to explain that the _intent_ of the law is to deal with the problem of orphaned works. It creates a process whereby out-of-print works can have have their copyright seized by the state, in order to make them available in digital form. Out-of-print works with a copyright date prior to 2001 are to be entered into a publicly available list. Listed works can be challenged for 6 months. Works that are not challenged within this period, have their rights seized, so that they can be published again.

Perhaps the specifics of the law are problematic, but on the surface, it looks like a great idea to me. Authors get rights to their works for 11 years, after which, if the work remains available, things proceed as they do now. But out- of-print works whose authors cannot be found, can be legally made available again. And the process has checks on possible abuses.

So what's the problem?

<comment><USER3> This in is essence exactly the argument that Google Books is using so copy/paste all the arguments against that (the French were particularly vocal) to see the problem.

If I had to choose between the government (French, US, whatever) and Google doing such a thing, I would _definitely_ choose an entity like Google on the grounds that since they stand to make money and have a stake, they'll manage it better than a typical government can.

<comment><USER4> The difference between a corporation and a government is that the corporation has a clear conflict of interest. Also, keep in mind that French governmental organizations are typically less dysfunctional than American ones.

<comment><USER5> _French governmental organizations are typically less dysfunctional than American ones_

Sorry, the research I've seen has shown the American government to be marginally more effective [1] and marginally less venal [2] at a much lower relative cost [3] than the French government. Quangos are usually in a class of their own when it comes to derision for public sector inefficiency [4].

[1] <http://info.worldbank.org/governance/wgi/worldmap.asp> (2010 Government Effectiveness)

[2] <http://cpi.transparency.org/cpi2011/results/>

[3] [http://en.wikipedia.org/wiki/Government_spending#Government_...](http://en.wikipedia.org/wiki/Government_spending#Government_spending_as_a_percentage_of_GDP)

[4] <http://www.economist.com/node/18867672>

</comment></comment></comment></comment><comment><USER6> This appears to be an attempt to make orphan works available to the public. While I might like to see adjustments more friendly to authors (a longer period before being appropriated, easier terms under which authors may retrieve distribution of the work on their own terms), I'm not opposed to this measure in principle.

</comment><comment><USER7> I would really like to see a sane analysis of this law. From this article it could merely require registering your copyright to use it, if it's more than a decade old. Which I personally would consider a sane way out of the current mess when it comes to finding someone to pay when remixing, resampling and quoting outside of fair use.

However given the opponents this probably isn't the case. But this article gives us nothing.

<comment><USER8> I recommend this in-depth analysis (in French, published on Feb 19): [http://scinfolex.wordpress.com/2012/02/19/oeuvres- orphelines...](http://scinfolex.wordpress.com/2012/02/19/oeuvres-orphelines- une-conclusion-en-forme-de-trompe-loeil-legislatif-et-les-consequences-a-en- tirer/) (Creative Commons license, with attribution).

</comment></comment><comment><USER9> Happy to see that the Pirate Party is standing up for fair copyright laws regardless of who their opponent is. Hopefully this law will whither away.

<comment><USER10> Not so in this corner. Use of the idea of fairness in argument is a red flag suggesting a lack of foundation by the person arguing.

I think this opposition suggests that the party takes its positions from who its opponents are, rather than extending from a coherent underlying philosophy.

The Pirate Party should take a strict line - abolish copyright altogether - rather than buying into the premises of their opponents but then trying to make a murky case about fairness.

The French law could lead to good things. I'm on the lookout for an event where a government makes a significant concession against copyright and then finds that there are trade advantages to it. A well-publicised example of this could cause the floodgates will open, and there will be a race to liberalise.

I see a parallel to the period of history where England lost the US colonies. They abandoned mercantalism for a free-trade model, and actually got richer despite the loss of a major colony.

<comment><USER9> From what I understand of the Pirate Party's mandate on copyright law, it seeks only to reform -- not abolish -- current copyright shenanigans. I got this information from the Pirate Party of Canada (but I'm pretty sure it's a universal mandate).

</comment></comment></comment><comment><USER11> Once again, France proves itself the paradise of Socialism... This is utterly unbelievable.

<comment><USER12> Unbelievable is the level of comment on HN. Let's see, the law:

1\. Aim to make available orphaned work. 2\. Only applies to work unpublished for at least 5 years. 3\. The public publishing right can be revoked by the author or publisher. 4\. The author is getting royalties. 5\. There is no censoring.

Let's compare to another somewhat related case of royalties land grab, iPhone publishing:

1\. Aim to control and profit from other people work. 2\. Applies to all iPhone published work from day one. 3\. There is no alternative other than not publish your iPhone app. 4\. Apple gets a cut, always. 5\. Apple gets to decide what gets published or not, unilaterally.

It's funny also to compare this to, say, how the music radio system works. Hey, it's compulsory diffusion of work without the author consent with a government-prescribed royalty payment system. For current works. Ah, but music radio stations are mostly privately owned, so this all right?

All in all, the law is reasonable and makes a honest attempt to leave the author in control. I could even envision that small and amateur author would want their work exclusively distributed by such a system, if the royalties are fair.</comment></comment>


CakeML: A verified implementation of ML - <AUTHOR> https://github.com/CakeML/cakeml <comment><USER4> The best thing since FLINT. My scheme here was to piggy back on it by implementing fast, compatible DSL of CakeML in Racket or something. Do prototyping and testing with fast one. Once ready, compile functions with verified one. Works best for tools that will still have acceptable performance or run in batches overnight. Implement it on Verisoft stack if still available for down to CPU correctness.

Also, some recent threads are on trustworthy compilers with verified vs reproducible builds. The ML languages have made robust compilers much easier to write. One can use this one for that to further reduce TCB and make compiler still easier to write vs C or whatever.

<comment><USER5> > The best thing since FLINT.

I assume you mean something related to?:

[http://flint.cs.yale.edu/flint/software.html](http://flint.cs.yale.edu/flint/software.html)

I can't seem to find anything directly related to the software part - <USER3> SML/NJ a verified implementation of ML'97?

I was exposed to a bit of Standard ML in university, and it always felt "nicer" than OCaml - but also less practical for actually getting anything done (probably because more people actually write real software in OCaml than in SML?).

As for Racket and SML, I came across the following existing projects:

"This is the Standard ML language embeded in PLT Scheme.": [http://planet.racket- lang.org/display.ss?package=sml.plt&own...](http://planet.racket- lang.org/display.ss?package=sml.plt&owner=chongkai)

"A Standard ML to Racket Translator without type inferencing and checking": [https://github.com/stslxg/sml-racket](https://github.com/stslxg/sml-racket)

And while I like the concept of Racket (I've yet to play with it as much as I think it deserves), why not simply use SML/NJ or MLTON if CakeML is a subset of SML? Or possibly implement a non-verfied implementation either on top of MLTON/SML/NJ, or _in_ ML? Curious about your line of thinking there.

<comment><USER4> "I can't seem to find anything directly related to the software part - <USER3> SML/NJ a verified implementation of ML'97?"

The page says it's included in SML/NJ distribution. Probably one of the tarballs. SML/NJ is just an old compiler for SML 1997. FLINT is techniques and code needed to certify compilation. They're different things but apparently bundled.

"probably because more people actually write real software in OCaml than in SML?)"

That's what I've gathered. The SML people have strong academic focus with Ocaml people having more practical focus. A big community built up around it.

"As for Racket and SML, I came across"

That's neat but they both have no type checking. I'll skip to next question as it's relevant here.

" Curious about your line of thinking there."

LISP is easy to parse, easy to interpret, has robust compilers, supports incremental compilation of individual functions, modify/debug a running program, and especially extension with macros. Racket is a batteries-included LISP with IDE, active community, and strong support for DSL's.

Now, ML's strengths are strong typing, type inference, easily integrated into formal verification, lots of prior work/tools in that (incl compilers), and easy to model w/ macros. Embedding ML in a LISP gives me the best of both worlds. I once did this in a 4GL to have rapid development with extraction to C/C++ with safety, portability, etc stuff auto-inserted. Easy parsing also lets you extract to a number of ML's or LISP's to use their tooling to catch extra errors in yours.

I've only run into two tools outside of Racket doing this sort of thing:

[https://github.com/combinatorylogic/mbase](https://github.com/combinatorylogic/mbase)

[http://julialang.org/](http://julialang.org/)

Mbase is used in commercial tools for static analysis, etc. It's a LISP and toolset custom designed for easily making things like compilers that comes with many DSL's for specific tasks, including ML. Julia raises the bar for 3GL language experience via a compiler written in LISP (femtolisp) that immediately translates the AST's into LISP expressions and works from there. It's more advanced than, but similar advantages to, the 4GL I wrote as it combines best properties of static typing, dynamic productivity, macros, and C support. Underlying LISP that enables that is only about 1,000loc to implement IIRC.

So, that's my thinking. I also thought of implementing the tool in MLton, too, but such things are even easier when your tooling and language makes extractions trivial. ;)

</comment></comment></comment><comment><USER6> > A long-term goal is to make proof assistants into trustworthy and practical > program development and implementation platforms. The CakeML compiler > verification is an example of proof-assistant-based development; > specifically, of proven-correct synthesis of machine code from higher-order > logic specifications.

Is CakeML intended to be used to make things, or is it more of a proof of concept?

<comment><USER7> "practical program development" implies that it is intended to make things and is not just proof of concept, no?

<comment><USER6> I read it as they're talking about making proof assistants practical one day, and CakeML is a step on the road to that goal. If they then move onto the next step, where does that leave CakeML?

</comment></comment></comment><comment><USER8> I'm sorry, but why do people still use HOL? It seems so much more annoying than type-theoretic approaches (Coq/Agda/Idris/Lean). [Cool work judging from the title nevertheless.]

<comment><USER9> HOL is a classical rather than constructive logic.

Moreover, there is less concern about soundness of the logic.

<comment><USER10> Could you post some links on the soundness comment? I share a fellow siblings comment of a little skepticism? But I'm neither a professionally nor scholarly logician, though I've read and owned (a couple of times) Van Heijenoorts From Frege to Godel, so feel free to throw some meat my way if you follow up with this comment.

<comment><USER9> Well-developed proof assistants like Coq and Isabelle/HOL are the current pinnacle in scientific rigour. But soundness of a foundational system is always a worry and will always remain so. By Goedel's 2nd incompleteness theorem, you cannot verify absolute soundness.

This is true for HOL just as for CoC/MLTT.

However, Coq, Agda etc have a much more expressive logic, which is less well understood, and I think a couple of genuine logical breakdowns have been found over the years in Coq and Agda, see e.g. [1, 2, 3], but they could all be fixed. (I'm not following the development closely, but I think the Coq/HoTT implementation even seems to require patching Coq to disable critical checks.) I don't think that the HOL tradition has had to revise logical foundations.

[1] [https://sympa.inria.fr/sympa/arc/coq- club/2013-12/msg00119.h...](https://sympa.inria.fr/sympa/arc/coq- club/2013-12/msg00119.html)

[2] [https://sympa.inria.fr/sympa/arc/coq- club/2014-01/msg00036.h...](https://sympa.inria.fr/sympa/arc/coq- club/2014-01/msg00036.html)

[3] [https://coq.inria.fr/cocorico/CoqTerminationDiscussion](https://coq.inria.fr/cocorico/CoqTerminationDiscussion)

<comment><USER10> this is fascinating! Thank you so much! I had no idea that the logic for Coq was more expressive, I can understand quite clearly how that can lead to breakdowns. I'm just slowly returning to this stuff through haskell.

Heady stuff, that second mailing list post.

</comment></comment></comment></comment></comment><comment><USER11> Awesome. If anyone knows about this project - how easy would would it be to re-target the backend code generator for something other than x86 or ARM?

<comment><USER12> It's reasonably retargetable. If you look under compiler/targets in the repository, you will find MIPS and RISC-V backends.</comment></comment>


'Call of Duty' wins First Amendment victory over use of Humvees - <AUTHOR> https://www.hollywoodreporter.com/thr-esq/call-duty-wins-first-amendment-victory-use-humvees-1287882 <comment><USER2> Have to be honest, I've always thought complaints about trademarked products in works of fiction were a silly thing to begin with. Why shouldn't a fictional universe feature products and businesses found in the real world? Are we supposedly to randomly assume all other universes don't have humvees or macbooks or the Red Cross? Who's to say the same people/companies/organisations would even be responsible in that work of fiction?

The law should basically just say there's no trademark violation in featuring a real world product/service in a fictional work so long as it couldn't reasonably be confused as a piece of marketing by the creator of said product or person. Obviously the work shouldn't be about say, Mickey Mouse, but it should be perfectly fine to feature say, Disney and their products as background elements in a fictional work without the approval of Disney.

Just seems ridiculous to have it work any other way.

<comment><USER3> What if I took your product and had it fail spectacularly in my movie?

<comment><USER4> Why should your product be protected from that?

Consumers are smart enough to know that fictional media is fictional. If we're not protecting products from negative reviews, opinion peices, or satire -- then fictional stories seems to me like a really weird place to draw a line.

What if I took your product and made a joke about it having ties to a cult?[0] I don't see any reason to treat fictional movies and games like they're a special medium.

I also assume we're not proposing that people should be banned from making fictional stories that feature real events and people. So jumping off of that point, what makes a movie that incorporates a public, trademarked brand different than a movie that incorporates a living public figure?

[0]: [https://entertainment.theonion.com/new-sesame-street- charact...](https://entertainment.theonion.com/new-sesame-street-character- shudders-to-life-as-produ-1840391716)

<comment> kube-system Being smart enough to know something is fake is not enough to be psychologically unaffected by it.

[https://en.wikipedia.org/wiki/Product_placement#Research](https://en.wikipedia.org/wiki/Product_placement#Research)

<comment><USER4> But to follow up, why should we protect brands from negative psychological associations in movies?

We still allow real products to be used in satires, even though satires could have the same unconscious effects you reference. We still allow people to publicly criticize products. We still allow real public figures and events to be referenced in fictional media, even though the same psychological effects you reference could negatively impact people's perception of them as well.

I still don't see anything that's special about a trademark that means it needs extra protection in this area.

<comment><USER5> > We still allow real products to be used in satires, even though satires

The brand owners still get licensing fees whenever real brands are shown, in movies

<comment><USER4> I am not a lawyer, and I'd welcome input from a real lawyer. But I am almost certain that satirical references to real brands are protected by fair use. I similarly suspect that licensing is not a legal requirement for movies.

I would be curious how you square your claim with _Rogers v Grimaldi_ [0], or more directly, how you square it with the outcome of the very case we're commenting on.

[0]: [https://en.wikipedia.org/wiki/Rogers_v._Grimaldi](https://en.wikipedia.org/wiki/Rogers_v._Grimaldi)

<comment><USER5> [https://www.inta.org/TMR/Pages/vol99_no6_a2.aspx](https://www.inta.org/TMR/Pages/vol99_no6_a2.aspx) Pay attention to huge vulnerabilities like (6) the defendant's intent in adopting the mark, wherein the defendant will have to show how a property was not used for a purpose, that the plaintiff will take issue with. Does anyone remember the Ford suit to stop news outlets from showing jihadists driving around in Ford pickups?

Rogers v Grimaldi is a narrow ruling in a district court about a celebrity name. It does not apply broadly to all branding and it's generally not worth a court battle to find out, since the filing is going to benefit the plaintiff.

That being said, there are consequences outside of pure legal issues to deal with in media production, which makes things like Apple's "allowance with their own restrictions" work. It's not a legal issue, but they can attack your post production just as well as making it a legal issue about filming.

</comment></comment></comment></comment></comment></comment></comment></comment><comment><USER6> Nice! I know Books and Movies have first amendment protections, but some reason people debate about it for games. I remember another similar story on HN a while back and someone said they were contacted to remove a mailbox they posted to a model sharing site because it looked too similar to a real life mailbox. But as far as I know they didn't push back, but I felt that company was abusing things, especially since they sent a DMCA which doesn't cover trademark disputes - but I guess most companies don't care and will take it down if they get a notice since they feel it's the courts job to decide if it was valid or not if someone decides to fight back. I guess legally, companies just act as a middleman doing a process so they won't be held legally liable even if the notice is wrong so they can keep their safe harbor instead of picking sides.

Then I remember the case where a real life club got mad at grand theft auto. But in the end it was decided people wouldn't confuse a night club in real life with one in a virtual world. Probably would be the same for that mail or car example too. And they didn't even use the logo, the shape or colors of things can count as a trademark.

</comment><comment><USER7> I really can't understand how could a lawsuit like this were valid in the first place.

The purpose of trademark is to prevent the counterfeit item be recognized as the same as trademarked item.

If the item is truly meant to refer the trademarked item, in this case realtime 3DCG rendering, there is no violation of the trademark. Isn't it? It's the same reason I can write any trademarked term here and not violate the trademark law.

US law system is beyond my understanding.

</comment><comment><USER8> Maybe this will mean that games won't have to make up whacky (and confusing) off-brand names for every gun.

<comment><USER9> I love those little ingame props, or they can reflect a lot of interesting nuances and opinions about weapons.

<comment><USER10> Or on "The Simpsons." Things like the Kwik-e-Mart, Krusty Burger, Duff Beer, and characters like Rainier Wolfcastle are more amusing than what they parody.

</comment></comment></comment><comment><USER11> I'm not sure how this will go on appeal and to what extent it will have general applicability as precedent. It would be great if e.g. racing simulators could depict cars without needing licensing (and imo it's ridiculous that they can't already do so, given that there isn't really any scope for confusion as to who is actually selling the car).

</comment><comment><USER12> I honestly don't know which is worse, a contract manufacturer complaining about unlicensed brand depictions or what happens in hollywood: [http://movieline.com/2013/02/06/military-entertainment- compl...](http://movieline.com/2013/02/06/military-entertainment-complex- hollywood-pentagon-relationship-battleship-zero-dark-thirty/)

</comment><comment><USER13> The HMMWV is on its way out. Orders for the vehicle are decreasing and will (or maybe already have) stopped. The vehicle is being replaced by the JLTV and MRAP (among others).

</comment><comment><USER14> Amazed that art (albeit military propaganda art) won out over the wishes and possibility of merchandising by an actual war profiteer.

<comment><USER15> That's because the video games industry gets tons of money from the military.

</comment></comment><comment><USER16> What about Gran Turismo. AFAIK they license all the cars. Does this mean they won't have to license them anymore?

</comment><comment><USER17> I probably don't know what I'm talking about, but it seems to me that many companies pursue legal action that is against their own interest. Surely, Humvees in CoD could only help the brand, no? Moreover, the fact that they don't even sell any consumer products in the first place makes the entire suit even more dubious. The use of Humvees in CoD is going to sow confusion among the military purchasing officers and they're no longer going to buy them? It just doesn't make any sense.

I'm beginning to think that a lot of these types of lawsuits stems from the lawyers themselves recommending them and somehow convincing the management to go along with it. After all, they're really the only party that wins regardless of the outcome of the case.

<comment><USER18> I also don't know what I'm talking about, but I think one of the core responsibilities of a trademark owner is that you establish a history of defending it. I heard once that if you don't do that you risk losing control of your rights to that property. Any smarty pants on here able to confirm/set me straight?

<comment><USER19> Yep, so this serve the companies interest because they're trying to defend their trademark; even if they failed. I doubt Humvee is in danger of becoming a generic term (Jeep is more likely; I cannot tell you much my it annoyed me my ex called her Suzuki 4x4 a "Jeep" .. it's not a Jeep! It's a 4x4 or off- roader.." but if they enter into other trademark battles, the opposing council can't say "Well they haven't tried to defend their trademark before now..."

<comment><USER20> Interesting you bring up a point about Jeep. Never once in the US I've heard of a non-Jeep-made SUV referred to as a "Jeep". But back when I lived in Russia, every single SUV was referred to as a "Jeep". I don't even know of another word for SUV in Russian. Not trying to argue against you btw, I just personally find stuff like this interesting.

EDIT: just checked the wikipedia page for SUV in russian, and yep, in the second paragraph it says that SUVs are usually referred to as "Jeeps" in post- Soviet countries.

<comment><USER21> i can answer that. russians are retarded (source: am russian). they see a new thing, and think anything written on the side is the name of it. Examples: marker =flomaster. clearly flow master, name of the guys who made the first marker seen in russia. hard drive =winchester. the model of the first hdd seen by russians. and don't try to tell them black olives are olives. they're masleeny, translating to 'oily'. because the first green oluves russians saw were in water, and the black ones were in oil. so they're not olives.

not limited to russians. i hangul, pantyhose is 'pantysuitking'

<comment><USER20> Oh god, I completely forgot about "winchester", since it's been over a decade since I've heard someone say it. And yup, fully agree on all your points.

<comment><USER21> even with das coolz english words sneaking in, and markers becoming markers, it's half-assed, in true slav style. the new russian cool-kids did ditch 'winchester.' and replaced it with 'stiff disk'

however anything that's a usb stick, be it a modem or wifi card, is still 'flashka.' sticking a cell modem in a usb port makes it flash memory. i hear with usb-c new lingo will take over. anything usb-c will be called djest' (stiffness)

<comment><USER20> "Stiff disk"? I thought "zhestkiy disk" would translate to "hard disk" just as well, which is not that far off from the actual english name for HDD/Hard Disk Drive.</comment></comment></comment></comment></comment></comment></comment></comment>


It Finally Occurred to Someone to Crowdsource the Weather - <AUTHOR> http://motherboard.vice.com/read/it-finally-occurred-to-someone-to-crowdsource-the-weather/ <comment><USER2> Sorry, I haven't had a chance to review the article yet, but hasn't PressureNet[1] been crowdsourcing weather data for years now? I know I've been silently contributing ever since the Galaxy Nexus was the new phone on the block with it's fancy barometer.

[1][https://play.google.com/store/apps/details?id=ca.cumulonimbu...](https://play.google.com/store/apps/details?id=ca.cumulonimbus.barometernetwork)</comment>


The Duqu 2.0 persistence module - <AUTHOR> https://securelist.com/blog/research/70641/the-duqu-2-0-persistence-module/

<comment><USER2> the compromised foxconn cert is extremely alarming to say the least

<comment><USER3> For me, at least, that's the key takeaway from this.</comment></comment>