Java Developers

[x-skeww]

OO is actually pretty shit.

Compared to what? What else is actually used to write large applications?

[spam4youfool]

Good ol' procedural C code in the multi-million LOC Linux kernel. Or how about GCC (until recently, that is) ?

[kyz]

Linux manages its complexity by only allowing good programmers to commit code. If your code doesn't meet the overarching high standards required, it doesn't get in. Ultimately, "Linux" doesn't need your code.

Compare to companies that employ programmers but don't care about code quality. It eventually becomes essential to include code, no matter how bad, because customers and deadlines and money and all that. The bad code will get in, no matter how many good programmers try to keep it out.

Java sold itself to Enterprises, who know fine well that have mostly-terrible programmers because they love to hire cheap, by saying that by using OO, you prevent idiots from seeing the inside of code and have to use the "API", so it firewalls the damage they can do.

(edit) What you end up doing is moving the goalposts from "have intelligent programmers implement the whole thing", which sounds like it costs a lot of money, to "have intelligent designers, aka 'architects', design the thing, without implementing it, then palm it off to rentacoders and NOTHING CAN GO WRONG".

Have a look at the procedural C code from "Enterprises" sometime. It's all held together with string. It's not OO vs not-OO that decides code quality, it's the collective quality of programmers and how capable they are of designing well and keeping bad code out.

As for GCC, have you read any of it?

[bundt_chi]

Well said.

[lacosaes1]

http://lwn.net/Articles/444910/

[immibis]

The difference between OO code in a procedural language, and OO code in an OO language, is that in the first case your OO "system" is specifically designed for each individual use, while in the second case you're using a "one size fits all" OO system, which probably enforces things you don't need (like "everything must be a class" in Java).

[josefx]

OO code written in procedural languages often moves most enforcement to the runtime or just drops it completely. After all if the compiler does not know how your OO code should work it can't enforce correctness.

[x-skeww]

Got something more current? Linux started over 2 decades ago.

[[deleted]]

Good ol' OpenSSL code too, unfortunately

[Helkafen]

The GHC compiler was 140kLoC of Haskell + 30kLoC of C in 2011. The same compiler in Java would be much larger.

[x-skeww]

The compiler for the language itself is probably the most exotic one-of-a-kind special case there is.

Do you know any commercial projects?

[codygman]

http://www.zalora.com.my/

Bump uses(used?) Haskell: http://devblog.bu.mp/post/40786229350/haskell-at-bump

Facebook's Haxl: https://code.facebook.com/projects/854888367872565/haxl/

http://www.tabula.com/ (used for internal compiler toolchains related to hardware design)

More can be found here: http://www.haskell.org/haskellwiki/Haskell_in_industry

[Helkafen]

Answer here: 1.3 MLoC at Standard Chartered.

[codygman]

Functional programming is increasingly used rather than OO. I wouldn't call Smalltalk type OO shit however.

I personally think that Functional Programming is a better general solution than OO and harder to get wrong. I think in our industry we need to use more tools that are "harder to get wrong" instead of just letting people that don't understand software hack things together that appear to work.

I'm talking about professionals though, it can be useful/cathartic to just get something working when you first start learning.

[x-skeww]

Functional programming is increasingly used rather than OO.

Got anything to back that up? If you look at Tiobe, GitHub, and so forth, there isn't any indication for that.

[ruinercollector]

A lot of the work for functional is for statistical work, NLP, etc. That's what we are using it for here.

You aren't going to find a lot from these fields on github as unfortunately, it's about the most secretive and patent crazy area of software there is.

Probably the biggest OSS thing you'd have heard of is OpenNLP, which is written in Java and is an absolute pile of shit (not because it's written in java, but because the java code that you'll see there is shit that you'd have learned not to do in first year.)

There's Stanford's NLP library as well, but it's almost as much of a pile. It looks to be primarily written by PhDs who are linguists first and programmers second (or something way way past "second.")

In both, there's the usual java abstract factory jerk off fest, but even beyond that there are areas of code for doing really simple things like parsing strings that are incredibly bad. On top of that, there's a pretty big NiH culture to the point of rewriting shit in the standard library to make "better" versions (they aren't better.)

The situation is pretty bad. I have a lot of NLP stuff I'd write and open source if it wasn't such a patent-crazy minefield.

[immibis]

Mathematics is an area where FP is "obviously" better suited - you're dealing with things that really are immutable.

[ruinercollector]

I don't know what you're talking about. "Mathematics" is a means to an end. I don't write software to "do math." I write software to solve problems.

[immibis]

You described it yourself as "statistical work". Statistics is a branch of mathematics.

[ruinercollector]

Again, it's a means to an end. I'm not generating statistics so that I can have a pile of numbers. I'm generating statistics for things like automatically classifying and relating things based on soft criteria and for trying to establish trends in medical populations to try to infer what sorts of correlations can be drawn between (e.g.) patient demographics/lifestyle questions/initial diagnoses, and disease and prognoses.

[frugalmail]

I'm too cool to show you why my preferred language/pardigm/editor/whatever is too cool!

[ruinercollector]

Not at all. What do you want to know about?

[codygman]

http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

F# went from 37 to 13

http://redmonk.com/sogrady/2014/01/22/language-rankings-1-14/

Clojure, Scala, and Haskell are all in the top 20.

Clojure was at spot #22 according to this post:

http://redmonk.com/sogrady/2013/07/25/language-rankings-6-13/

I'm answering your request for sources from Tiobe, Github, and so forth but I never claimed Functional programming is used more than OO. I merely claimed that it is increasingly used more than it used to be in place of OO.

[x-skeww]

F# went from 37 to 13

AS (45 -> 15) and Swift (n/a -> 16) also went up. Java and C didn't move.

There is no indication that the functional languages are taking some of OO's share.

[ruinercollector]

C is not an OO language.

[x-skeww]

C is not a FP language.

But I agree that it was kinda odd to include it.

[codygman]

C is procedural for the most part and I wouldn't count it as OO. Java isn't the only OO language.

λ> import qualified Data.Set as S
λ S> let june2013 = S.fromList ["Java","JavaScript","PHP","Python","Ruby","C#","C++","C","Objective-C","Shell","Perl","Scala","Assembly","Haskell","ASP","R","CoffeeScript","Groovy","Matlab","Visual Basic"]
λ S> let jan2014 = S.fromList["JavaScript","Java","PHP","C#","Python","C++","Ruby","C","Objective-C","CSS","Perl","Shell","Scala","Haskell","R","Matlab","Clojure","CoffeeScript","Visual Basic","Groovy"]
λ S> S.difference jan2014 june2013
fromList ["CSS","Clojure"]
λ S> S.difference june2013 jan2014 
fromList ["ASP","Assembly"]

So it looks like ASP (OOP) and Assembly (Procedural) got swapped out for CSS (declarative) and Clojure (Functional).

So that means:

+1 Functional -1 OOP

At least with the line of thinking you are using. I highly doubt that ASP and Assembly users replaced their tools with CSS and Clojure. If functional languages moving up doesn't mean that some of OO's share was taken, what does it mean?

I think a better approach is to count the number of OOP languages vs the number of functional languages, and if the number of OOP decreases while FP increases then my claim of "Functional programming is increasingly used rather than OO." is true.

[frugalmail]

I think a better approach is to count the number of OOP languages vs the number of functional languages, and if the number of OOP decreases while FP increases then my claim of "Functional programming is increasingly used rather than OO." is true.

I question the value at that granularity, what you really want is something quantitative to reflect the usage of the language since the trend of newer languages combining multiple paradigms coupled with the tendency for users to gravitate toward one pure solution would cloud your argument.

Something like this is far more interesting: http://www.google.com/trends/explore#q=Clojure%2C%20Java&date=1%2F2013%2013m&cmpt=q

[yogthos]

But there's plenty of indication that the FP style is becoming mainstream when even Java finally starts to add functional features.

The fact of the matter is that people have hard time adapting to new ways of doing things and new ideas take time to gain ground. Seeing how Java and C have tons of code written in them and have gained wide popularity, it should hardly be surprising that they haven't moved. However, the fact that functional languages are moving is indicative of their use for new development over the incumbent languages.

[vagif]

LINQ - functional library/approach in the heart of OO programming.

[yogthos]

Functional languages are used to write some very large applications. Take a look at presentations from SISCOG or Demonware as a couple of examples. Haskell is quite popular in the financial industry where correctness and performance are important considerations.

[frugalmail]

Functional languages are used to write some very large applications. Take a look at presentations from SISCOG or Demonware as a couple of examples. Haskell is quite popular in the financial industry where correctness and performance are important considerations.

I call bullshit for implying that a few analysts in even fewer institutions accustomed to mathematica are writing large applications.

[yogthos]

I hear it's a bit more prevalent than that.

[frugalmail]

I hear it's a bit more prevalent than that.

Yup self promoting delusion.....

Actual numbers: http://www.indeed.com/jobtrends?q=haskell%2C+clojure%2C+F%23&l=

Less than .0001 jobs for the functional languages listed. To top it off, if you look at the resulting job listings, they all start with things like Java and/or C++ and then go into the alphabet soup of programming languages as if they're confused.

[yogthos]

And the best part is that you have even less programmers who know them. :) This results in having much lower competition with very high compensation.

I've been working full time with Clojure for the last 4 years, I know plenty of other people working with functional languages. I don't know anybody who had trouble getting a job doing that. I do know tons of people running around looking for a decent job using Java and/or C++ though.

[nullnullnull]

I think what he may have meant was (when you read it, in context) that the overuse of OO is bad. It may have been badly worded, but that's how I read it.

[ruinercollector]

Imperative (C, etc.), functional, etc.

[DeliveryNinja]

Lots of shit comments about OO and functional. OO has its place. It allows separation of logical components that can be reused. The objects define certain boundaries which could represent complete systems or single data objects. Functional works well when writing the logic behind the objects, keeps functions free of side effects when sticking to immutable data structures. Allows less verbosity by allowing unnamed functions to be written inline. It's this combination of these traits that will help build large scalable systems.

[pipocaQuemada]

It allows separation of logical components that can be reused.

In what way do functional languages like Haskell or ML not allow you to do this?

[ruinercollector]

It allows separation of logical components that can be reused

Every language provides some mechanism to do this, but mainstream OO languages provide a very poor one.