News for hackers. Stuff that matters.
Re:135M messages a second between processes in Java (2013) by wtbob on Saturday August 13, 2016 @08:55PM (#12283810)
> The JVM is a treasure just sitting there waiting to be rediscovered.

It's the result of man-centuries (man-millennia?) of work, yes, and as a result is really, really impressive. But imagine if that much work had been put into something fundamentally great, like Smalltalk or Lisp, rather than something fundamentally okay like Java.

> It really is a shame that there is so much noise and unnecessary complexity around using it.

Very true. Java itself is not a terrible language (hence why I wrote 'fundamentally okay' above); it's the arcane, rococo, lunatic levels of ritual which surround it. Every time I look at Java code I'm reminded of some insane fantastic court in which one has to plead with the Minister of Small Affairs, make a sacrifice to the God of Bureaucracy, pay for a Token of Token-Paying, appeal to the good graces of the Wise Undersecretary of Vice-Small Affairs and finally spend a weekend climbing an Escher Staircase before an audience with the King, all just to get a scrap of toilet paper.

Re:135M messages a second between processes in Java (2013) by niftich on Saturday August 13, 2016 @09:18PM (#12283868)
(Edited to clarify that I think Java was good in the very beginning, less so in the middle, and is good once again)

Java started off as the Golang of the 90s: small, simple, opinionated, statically-typed, in many ways state-of-the-art, and engineered to protect the programmer from doing bad things (either due to ignorance or will). It came with a batteries-included standard library.

Then, in a quirk of fate, it became very popular. Though its library provided clean abstractions, you had to chain several of them together to actually accomplish anything: this is why it was so verbose. Everyone was writing Java, but no one was sharing Java, yet. Before Apache (Jakarta) Commons, no one bothered to make wrappers for basic stuff... just like how we were writing bad JS before jQuery or underscore came out. We were caught between our own experimentation, Sun's desire to take over the desktop, and companies like IBM and Oracle that wanted to ensure they could sell commercial support for big monolithic Java appservers.

When the 'Design Patterns' book came out, someone should've made a framework, but instead we sprinkled AbstractStrategyFactoryBuilders everywhere because that's what the enterprise libraries did... and it read like a bad parody of object-oriented programming, but by now, we've learned our mistake.

Now that bad APIs have fallen out of favor, Java EE is nearly abandoned, Spring brought some sanity but also forced us to consider why we're even thinking about convention over configuration, Java is much, much nicer. In the Maven, Github, CI world, we can -- environment and company policies permitting -- easily pull in libraries and frameworks that allow us to actually get stuff done at the correct level of abstraction.

Re:135M messages a second between processes in Java (2013) by ap22213 on Sunday August 14, 2016 @01:16AM (#12284357)
This is a lot different than I remember. As I remember it, Java was touted as a compile-once run everywhere language. Back then, you had many different flavors of UNIX, with different hardware architectures, and in practice, software was deployed (and supported!) directly on customer servers (web services didn't exist). Plus, this was a time when pretty much all code was written in C. Virtual machines with garbage collection were academic research projects.

Java (until recently) was always a sub-par language. It was difficult to work with and behaved in unexpected ways. Academics hated it because there were much better grammars. Engineers hated it because it was slow and rigid compared to C. Gosling designed it for embedded systems, of all things. But, it aimed to solve a very expensive problem, and lots of hype was directed at it.

(Edit: I should have emphasized that the tooling really sucked more than the language. We had fantastic C compilers and IDEs. And, Java had immature tools. Worse, you had to manually build Jars and package your Jars appropriately. Ant, Maven, Gradle, etc didn't exist.)

Also, the GoF authors didn't write design patterns as a response to Java. They wrote it as a retrospective on large software systems - what worked and what didn't. The 'patterns' were called such because they were observed in many independent projects, each having been reinvented time and again. The patterns proliferated with Java EE architects who pushed patterns as common ways to communicate standard design principles. You have to keep in mind that this was also a big time for 1) RAD, 2) UML, and 3) software factories. Large companies were sold a vision than in a very short period of time all they would need would be an 'enterprise architect' who would 'draw' the software, hit a button, and out would come the complete system.

Re:135M messages a second between processes in Java (2013) by mindcrime on Sunday August 14, 2016 @01:25AM (#12284379)
Java (until recently) was always a sub-par language. It was difficult to work with and behaved in unexpected ways.

Every language has its idiosyncrasies to be sure, but this doesn't really jibe with my recollection. I remember Java being a much better alternative to C++ in many ways, including (and especially) binary object compatibility which made it possible to effectively use libraries. Remember how C++ libraries had to either be pre-compiled for your platform (which the same compiler you were using, etc.) OR be shipped as source.. and given C++'s blazing fast compilation times cough cough, well....

Anyway, in 2001 we were building Java IVR applications on Windows and shipping the jars to AIX machines and running them with no problem. The "write once, run everywhere" thing certainly wasn't 100% true (especially for desktop apps using Swing) but for many applications it really was the case (or close to it).

Re:135M messages a second between processes in Java (2013) by ap22213 on Sunday August 14, 2016 @01:50AM (#12284422)
I'm sure it worked well in many cases. But, in our case, we were developing for Solaris, AIX, HP-UX, and Windows NT. The VMs would behave differently in different environments, and I remember VMs stack dumping on many occasions which became a major support headache. We used to call it 'build once, run nowhere.'
Re:135M messages a second between processes in Java (2013) by mindcrime on Sunday August 14, 2016 @02:44AM (#12284531)
But, in our case, we were developing for Solaris, AIX, HP-UX, and Windows NT. The VMs would behave differently in different environments, and I remember VMs stack dumping on many occasions which became a major support headache. We used to call it 'build once, run nowhere.'

Interesting. The only thing I really remember people complaining about a lot was thread scheduling. Java always let you set a thread priority and a lot of people tried to use that to make things behave in very specific ways, but - if I recall correctly - it was the case that that behavior was always allowed to be platform independent and couldn't be relied on to create a consistent cross-platform experience. Outside of that, it seemed like UI issues with Swing (or, I guess, AWT) were the main things people ran into trouble with.

What time frame was all of this for you? Wondering if it was just the very early days of Java before some of the problems were resolved.

Re:135M messages a second between processes in Java (2013) by beagle3 on Sunday August 14, 2016 @11:19AM (#12285890)
Also, Java only provided the lowest common denominator. A piece of software I worked on back then needed to start a long 2hr process, but only if there was more than 2GB of free disk space (which was not a trivial requirement circa 2000). But Java did not have a way to query free disk space at the time because IIRC it was missing on one of the platforms (and then it wouldn't be "run everywhere"). So instead it would run, and if insufficient disk space would just fail.

Java was always "write once, debug everywhere"

Re:135M messages a second between processes in Java (2013) by pjmlp on Sunday August 14, 2016 @01:47AM (#12284418)
> Academics hated it because there were much better grammars.

Surely not at my university.

By 1998 it had already replaced C as the language for distributed computing classes.

C with SUN RPC or PVWM was just too clunky to keep on using and was used just as introduction to distributed computing.

Same with compiler design classes.

The ECOOP'99 was full of Java related presentations with the keynote of Jim Waldo about Jini, something that would just come in handy in our modern IoT days.

> We had fantastic C compilers and IDEs. And, Java had immature tools.

On which OS?

Visual Age, JBuilder, Zortech all were quite similar to their C and C++ siblings.

> The patterns proliferated with Java

Nah, they were already quite common in C++ with CORBA and COM/DCOM projects.

EDIT: typo to => too

Re:135M messages a second between processes in Java (2013) by ap22213 on Sunday August 14, 2016 @01:55AM (#12284433)
Sure, universities embraced it in the late 90s because it was easier to teach to undergrads, and CS programs were becoming cash cows. But, the researchers that I knew certainly weren't using it for their own Computer Science research (aside from VMs and heterogeneous environments).

Yeah, Jini was cool! And Tuple spaces, etc. There were some cool things being built on Java, but few people were embracing it as a silver bullet.

Re:135M messages a second between processes in Java (2013) by hota_mazi on Sunday August 14, 2016 @12:22AM (#12284251)
I feel you haven't taken a look at Java in the enterprise in a long time.

Spring is considered to be an overloaded bloated mess and Java EE has become lean and mean with plenty of very capable specifications and implementations (JPA, CDI, etc...).

And FYI, the Design Patterns book came out before Java (1994 vs/ 1995) so I think you have your timelines confused. The early editions of Design Patterns didn't contain a single line of Java, they were mostly C++ (and some Smalltalk).

Java is twenty years old, and for such an old geezer, it's adapted remarkably well (and between Java 8 and Kotlin picking momentum, its legacy seems to be well assured).

Re:135M messages a second between processes in Java (2013) by niftich on Sunday August 14, 2016 @12:57AM (#12284323)
I was trying to express a lot of ideas in a small space, and I have edited it since, but it's still not as clear as I'd like. You and I agree, but I have struggled to get this point across.

Spring is a bloated mess, but when it first came out it was lean new framework and a relief from EJBv1 and EJBv2. In response, EJBv3 was much better, but in the meantime Spring became the new normal, and grew into some strange swiss army chainsaw glue with now-deprecated awful xml configuration replaced by the horror of not-quite-code-but-compiled-into-the-classfile @Annotations!

The 'new Spring' is Spring Boot, which was a response to this then-obscure framework called Dropwizard which showed that all you had to do was pick a handful of very good libraries get work done. Guava, Jersey, Jackson, Jetty; some decent ORM, and you're good to go. Some of these are backed by new Java specs like JAX-RS and JPA that are legitimately pretty good.

I think the biggest problem Java still has in the hearts and minds of people outside the 'enterprise' is not because of Java, but because of the complexities that only manifest in environments where your code isn't 100% greenfield every time.

Dependency Injection isn't something you realize you need until you realize you need it -- and then you realize you need it Really Badly.

Externalized XML config files declaring reusable beans isn't something you think you need until your client is asking how they can reconfigure something in the shipped software when they can't just recompile it to what they need.

Re:135M messages a second between processes in Java (2013) by reitanqild on Sunday August 14, 2016 @02:37AM (#12284519)
> the horror of not-quite-code-but-compiled-into-the-classfile @Annotations!

I really don't get the hate to annotations.

They have saved me lots of hours since 2009 and at close to zero cost. What's not to like?

Re:135M messages a second between processes in Java (2013) by niftich on Sunday August 14, 2016 @03:09AM (#12284592)
Since they're compiled into the code, it means you can't change them without recompiling, so they're not actually configuration. But they're not actually code either, so they can't be subclassed or inherited, don't support generics, and have other quirks [1]. Furthermore, they are a sort of explicit notation to make you feel like you're getting 'convention' over 'configuration', but if it were truly convention you wouldn't need them in the first place.

For example, to teach my class how to serialize itself into JSON, I can compile com.fasterxml.jackson annotations into it, but by doing so I've made a particular JSON library a dependency of myproject-datatypes. I'd rather my myproject-controller or some other layer of my application take care of how the data looks over JSON. Luckily Jackson supports an entirely different way [2] of teaching it how to map a class, but not all libraries are so nice.

That is not to say annotations don't have their place. They're good declarative structures, but in my opinion they are used in places where they shouldn't be. This blog post [3] from 2009 accurately describes how I feel about annotations.

[1] http://www.cowtowncoder.com/blog/archives/2009/02/entry_216....

[2] https://github.com/FasterXML/jackson-docs/wiki/JacksonMixInA...

[2] http://naildrivin5.com/blog/2009/03/11/java-annotations-java...

Re:135M messages a second between processes in Java (2013) by hota_mazi on Sunday August 14, 2016 @04:01AM (#12284704)
Annotations are data about the code. The fact that you can't change them without recompiling the code is a feature, not a bug.

If you want that kind of flexibility, use external files (e.g. XML) but now the two can get out of sync, which is what is commonly referred to as XML hell.

The rule of thumb is simple: whenever you need to add information about something in your source (class, method, field, package), use an annotation. If you need to add information about something that is not source code (port, host, various sizes, etc...) then use an external file. In particular, if you specify a reference to Java code in your XML, you should use an annotation instead.

Re:135M messages a second between processes in Java (2013) by twic on Sunday August 14, 2016 @07:29AM (#12285175)
> to teach my class how to serialize itself into JSON, I can compile com.fasterxml.jackson annotations into it, but by doing so I've made a particular JSON library a dependency of myproject-datatypes

Right, because at the moment, there is no standard cross-library convention for that. One day, there will be, as there is for serializing to XML:

http://docs.oracle.com/javaee/7/api/javax/xml/bind/annotatio...

Re:135M messages a second between processes in Java (2013) by blackflame7000 on Monday August 15, 2016 @02:49PM (#12292546)
What about gson?
Re:135M messages a second between processes in Java (2013) by twic on Tuesday August 16, 2016 @05:48PM (#12300898)
It's not a standard, just another implementation.
Re:135M messages a second between processes in Java (2013) by reitanqild on Sunday August 14, 2016 @04:13AM (#12284739)
Thanks for taking time! My views below:

> Since they're compiled into the code, it means you can't change them without recompiling, so they're not actually configuration.

Neither xml was configuration. I cannot remember ever changing xml for deployment. Actually in many ways the whole build jar/war process feels a lot like compiling in Javaland and while I'll happily pick jars or wars apart for troubleshooting deploying the result in production would break multiple guidelines at most places I guess (hope).

> Furthermore, they are a sort of explicit notation to make you feel like you're getting 'convention' over 'configuration', but if it were truly convention you wouldn't need them in the first place.

Partially agree but then again every other framework I have seen demands you do something: put x classes in y folder, subclass another class or implement an interface or something.

Compared to magical directory layout annotations are less well, magic, more explicit.

Compared to subclassing it is more flexible (although I remember enjoying Propel with Symfony 1.)

Compared to marker interfaces? Not sure.

That said once you accept them there is plenty of things you don't have to specify but can override if you want/need to.

Edit: As for your third reference it is out of sync itself:

> The same goes for EJB. I have a class named FooStatelessBean. How about we assume it's a stateless session bean, and it's interface is defined by its public methods? It can then provide FooRemote and FooLocal for me, and I don't need to configure anything or keep three classes in sync

I only use three annotations on such ones: @Named at the class telling the DI framework to pick it up for injection using its name as the name (although I can override it right there and then if I need to.) @Stateless tells it to make a suitable bunch of them and that it is OK to give any of them out to anyone at runtime and @PersistenceContext (at an instance variable) tells me that I want a reference to the ORM layer.

I could easily create a combined annotation for @Named and @Stateless, even naming it @Stateless and just importing my @Stateless instead of the standard (across all Java EE implementations) one.

I guess I could also create a superclass that does all this and subclass it but some day I'll leave the project and another one will have to maintain it.

Could we have picked this out from the name? Yep. Would it be magical? Yep, more so than annotations. Would it tie my hands with regards to naming classes? Yep.

Re:135M messages a second between processes in Java (2013) by jacques_chester on Sunday August 14, 2016 @10:58AM (#12285813)
> which was a response to this then-obscure framework called Dropwizard

I sat in with an AMA in NYC with Dave Syer. He said it was inspired by a project he was co-opted to which used Rails.

Not the actual architecture of Rails, mind you, but the "just works", out-of-the-box, no-configuration experience.

Disclosure: I work for Pivotal. So do many of Spring's core committers. There's a lot of feedback from Labs and Cloud R&D into Spring, but they're still a largely self-directed team.

Re:135M messages a second between processes in Java (2013) by niftich on Sunday August 14, 2016 @03:32PM (#12286948)
Trying to upvote this because it's good info! But, but, I have one better :)

Spring Boot 1.0 GA Released [1] blog post, says, and links to a Spring Issue SPR-9888:

"It's been 18 months since the original request [2] to "improve containerless web application architectures", that gave birth to Spring Boot, was raised."

The body of the original issue [2] says, midway down:

"I think that Spring's web application architecture can be significantly simplified if it were to provided tools and a reference architecture that leveraged the Spring component and configuration model from top to bottom. Embedding and unifying the configuration of those common web container services within a Spring Container bootstrapped from a simple main() method.

Though there are many frameworks and platforms today that no longer require a container I think inspiration can be drawn most from DropWizard (http://dropwizard.codahale.com/).

Another project I've seen inspired by DropWizard but leveraging Spring is HalfPipe (https://github.com/32degrees/halfpipe). Though I don't think HalfPipe goes far enough. I think to truly provide simplification the entire architecture, wherever reasonable, must be embedded within the Spring container rather than without. Though it does have several other interesting ideas."

[1] https://spring.io/blog/2014/04/01/spring-boot-1-0-ga-release...

[2] https://jira.spring.io/browse/SPR-9888

Re:135M messages a second between processes in Java (2013) by jacques_chester on Sunday August 14, 2016 @05:41PM (#12287473)
It could absolutely be both. Dave Syer is not the only person who drove Spring Boot. Phil Webb is the main day-to-day driver, from what I can tell. He's definitely been active in soliciting feedback from Labs Pivots.
Re:135M messages a second between processes in Java (2013) by slantedview on Sunday August 14, 2016 @12:50PM (#12286284)
> The 'new Spring' is Spring Boot, which was a response to this then-obscure framework called Dropwizard

This is correct, but what pisses me off is that the Spring folks clearly copied Dropwizard, then failed to even mention Dropwizard in their various docs, blogs, talks, etc, which you're thinking is fine. But they DO mention other (less useful) projects as supposed alternatives for Spring Boot, essentially, pretending as if Dropwizard doens't even exist when clearly it's the reason that Spring Boot exists! Shameful.

Spring hails Boot as the new way of doing things, but it's still by no means a clean break for the rest of the Spring ecosystem where programming by XML (or annotations) is still king and the APIs are still a horrible, overcomplicated mess. There's no undoing that.

Re:135M messages a second between processes in Java (2013) by LoSboccacc on Sunday August 14, 2016 @02:47AM (#12284543)
Each tech it's use.

Annotations are great for class metadata - JPA or beans binding or servlets and filter paths.

Externalizing binding was the kind of nice thing that almost never quite worked right. XML (or YAML because sysads are people too) for configurable parts is ok, but if you need to mix and match services it was never ever needed. The binding API allowed that years before spring style of depencency injection brought madness into the enterprise world and in a extremely better and clean way, using the facilities of the language instead of creating ugly reflective glue that kind of worked

Re:135M messages a second between processes in Java (2013) by hota_mazi on Sunday August 14, 2016 @01:10AM (#12284343)
Agreed, I think you and I have very similar views on the JVM/JaveEE/Spring situation.
Re:135M messages a second between processes in Java (2013) by EtienneK on Sunday August 14, 2016 @01:46AM (#12284417)
Spring Boot is very good. I can't imagine writing enterprise Java code without it anymore.
Re:135M messages a second between processes in Java (2013) by atomashpolskiy on Sunday August 14, 2016 @04:59AM (#12284876)
You might want to try out http://bootique.io, it's even better in many aspects
Re:135M messages a second between processes in Java (2013) by twic on Sunday August 14, 2016 @07:22AM (#12285167)
> I feel you haven't taken a look at Java in the enterprise in a long time. > > Spring is considered to be an overloaded bloated mess and Java EE has become lean and mean

I agree with those descriptions, but we have very different experiences of Java in the enterpris. In the companies i work with, EE still means older specifications, and Spring, for all its flaws, comes in as a breath of fresh air.

Re:135M messages a second between processes in Java (2013) by agibsonccc on Saturday August 13, 2016 @09:39PM (#12283930)
I'd argue much of that time has passed now. I used to write J2EE code. Now we have frameworks like lagom and dropwizard which make life exponentially better. I'd suggest taking another look.
Re:135M messages a second between processes in Java (2013) by Zafira on Saturday August 13, 2016 @10:16PM (#12284017)
> It's the result of man-centuries (man-millennia?) of work, yes, and as a result is really, really impressive. But imagine if that much work had been put into something fundamentally great, like Smalltalk or Lisp, rather than something fundamentally okay like Java.

The eternal irony of this is the current JVM---HotSpot---was a Smalltalk VM that Sun bought. It was an attempt to commercialize some of the work done (also at Sun) on the Self language [1].

[1] http://c2.com/cgi/wiki?HotSpotVm

Re:135M messages a second between processes in Java (2013) by mikro2nd on Sunday August 14, 2016 @05:39AM (#12284999)
Well, "an attempt to commercialise" seems to me to trivialise it a bit.

The fact is that the Self research uncovered some pretty interesting things around optimisation... at the time optimisers were pretty much based on the research done in the '70's when structured languages were still quite new-and-all. The Self work uncovered that those assumptions were really quite bad when it came to OO environments. OO-structured programmes behaved quite differently at runtime. Indeed, one of the most surprising (then) results was that you really couldn't optimise all that well at compile-time, but that you needed continuous runtime analysis and optimisation do anything really effective. But when you do, then it's hella effective! Remember that we were still in an era when byte-code interpreters were viewed (mostly rightly) as woefully slow and inefficient.

Sun had part-funded the Self research for quite a number of years (>5? if memory serves me) so when they found themselves with a bytecode interpreter that really needed some serious help there was a natural fit, and why should they not have gained some advantage out of some pure research work they had funded?

As I recall it, most of the Self research was done at Stanford. Sun just provided money, and only much later in the project's lifetime, a home in Sun Labs ("Church" side of Sun).

(All this is purely from memory, so I might have misremembered bits of it - I can go upstairs and dig out all those old OOPSLA conference proceedings if it matters.)

Re:135M messages a second between processes in Java (2013) by cageface on Saturday August 13, 2016 @11:28PM (#12284156)
If Smalltalk and Lisp are so magical then why didn't they win?
Re:135M messages a second between processes in Java (2013) by twic on Sunday August 14, 2016 @07:43AM (#12285215)
Smalltalk has a strength and a weakness in its 'image' approach. Smalltalk doesn't really have source code and object code, it has an 'image' full of objects which you can run, and which contains all of the standard library, the development environment, and your code. You work in this image, and save changes as you go along.

That makes Smalltalk super easy and convenient to develop in, and very consistent across platforms. But it's a roadblock to publishing code, working as a team, deploying, and the other things you need to do with software that isn't a toy. The Smalltalk environment and community certainly have ways of doing all those things, but they can be clunky, and some of them are quite recent.

Meanwhile, C++ was a bit of a pain to write, but once you'd written it, sharing it was as easy as emailing a file, or checking it into RCS (or that hot new CVS thing), and building a production release was a matter of running 'make' and going for lunch.

Java kept C++'s simple approach. Smalltalkers at the time laughed at how caveman-like the experience was. But it turned out that that simplicity was exactly what you needed to grow virally on the then-nascent web.

Re:135M messages a second between processes in Java (2013) by oblio on Sunday August 14, 2016 @05:21AM (#12284957)
I don't get why you're being downvoted. Lisp had a 40 year head start, it had commercial backing in multiple iterations, it has a grassroots community that pesters the other to this day.

I can't say anything about Smalltalk because I don't know enough about its history, but at this point in time it's pretty sure that unless some sort of major event happens, Lisp won't ever go mainstream.

Re:135M messages a second between processes in Java (2013) by robotresearcher on Sunday August 14, 2016 @12:03AM (#12284224)
Because Worse is Better applies here as usual. Java was fast enough and familiar enough and the libraries were good enough and the language safe enough and Sun supported it well enough in the enterprise. Nothing else had the same combination of okayness. I never enjoyed Java but it had my half-grudging respect.
Re:135M messages a second between processes in Java (2013) by cageface on Sunday August 14, 2016 @12:31AM (#12284272)
I'd agree with you with the caveat that "worse" in that paper means that something might be less elegant or rigorous on a theoretical level but still the more practical choice.

And now that we have good, modern high level languages with robust but flexible type systems I'd choose Haskell or Ocaml or maybe Swift over Smalltalk or Lisp if I wanted to stick my neck out technically on a project. I consider dynamically typed languages to be significantly "worse" in an absolute sense for building non-trivial software.

Re:135M messages a second between processes in Java (2013) by wtbob on Sunday August 14, 2016 @09:27AM (#12285490)
> And now that we have good, modern high level languages with robust but flexible type systems I'd choose Haskell or Ocaml or maybe Swift over Smalltalk or Lisp if I wanted to stick my neck out technically on a project. I consider dynamically typed languages to be significantly "worse" in an absolute sense for building non-trivial software.

I don't know if there are any typed SmallTalks, but Common Lisp has optional static typing: you can declare types and the compiler will enforce them. This seems to me the best of both worlds: the freedom to interact with your program dynamically, with the safety of strong static types.

Re:135M messages a second between processes in Java (2013) by wtetzner on Sunday August 14, 2016 @05:15PM (#12287374)
But with Common Lisp, you don't get the safety of strong static types. If the compiler can prove that there's a type error, it will throw an error. That's not the same as throwing a type error when the compiler can't prove that there isn't a type error, as a sound type system would.

Even worse, Common Lisp will use your type annotations to optimize code, which can change the behavior of your program. It's better to think of them as type hints for optimization than to think of them as optional static types.

Re:135M messages a second between processes in Java (2013) by junke on Sunday August 14, 2016 @06:28PM (#12287635)
That's true, because doing so in Lisp is undecidable and because you allow function definitions to change (that's why type checking works better with inline and local functions).

The type of analysis applied to Lisp is adapted to its type system: you have ranges of values, unions, etc. In particular SBCL can exploit some relationships between runtime values and types (I detailed it recently, so I prefer not to repeat myself: https://news.ycombinator.com/item?id=12222404)

As far as I am concerned, it is already quite powerful to detect the type-related errors that I tend to do. The part that cannot be decided during compilation is left to be checked at runtime, which is strong dynamic safety. Instead of manipulating untyped bits, you have all you need to never corrupt the state of your program. The good news is that if implementors make progress with type inference, you don't have to change the language: more checks can move from runtime to compile-time (the hard stuff would be the check the "satisfy" type ;-).

With some types left to be checked at runtime, you end up in a situation that is no worse than statically typed programs which throw exceptions for other kinds of errors. Sometimes, those errors arise because programmers implement a dynamic things, like ad-hoc tags to identify objects at runtime (so this is basically a dynamic type system in disguise). Other errors related to safety are tied to temporal issues, deadlocks, permissions, priority, security, etc. You can't always encode them with types. There are formal tools for dealing with them, but at this point, whether you use them generate safe code in Lisp or OCaml is not very important (and generating Lisp code is straightforward).

> Even worse, Common Lisp will use your type annotations to optimize code, which can change the behavior of your program.

This is a strange concern. The modified behavior belongs to the set of behaviors that would be possible without checking types, not a new, faulty behavior that contradicts what the code says.

Re:135M messages a second between processes in Java (2013) by robotresearcher on Sunday August 14, 2016 @12:37AM (#12284284)
No caveat needed: that's exactly how I intended the use of 'worse'. I linked the original essay in another comment below.
Re:135M messages a second between processes in Java (2013) by hota_mazi on Sunday August 14, 2016 @12:24AM (#12284256)
> Because Worse is Better applies here as usual.

It's not that simple. They lost for very pragmatic reasons: Smalltalk and Lisp were worse than Java in many ways (even smaller than Java's initial implementations, Smalltalk's binary images were undeployable in production, these two languages are dynamically typed, etc...).

Re:135M messages a second between processes in Java (2013) by niftich on Sunday August 14, 2016 @12:36AM (#12284279)
[1] https://en.wikipedia.org/wiki/Smalltalk#History, scroll midway down:

"During the late 1980s to mid-1990s, Smalltalk environments -- including support, training and add-ons -- were sold by two competing organizations: ParcPlace Systems and Digitalk, (...) Both firms struggled to take Smalltalk mainstream due to Smalltalk's substantial memory needs, limited run-time performance, and initial lack of supported connectivity to SQL-based relational database servers. (...)"

"In 1995, ParcPlace and Digitalk merged into ParcPlace-Digitalk and then rebranded in 1997 as ObjectShare (...) The merged firm never managed to find an effective response to Java as to market positioning, and by 1997 its owners were looking to sell the business."

There was also Strongtalk, a strongly typed variant of Smalltalk. The guys who wrote Self and the guys who wrote Strongtalk were both eventually acqui-hired by Sun and they were the ones who wrote HotSpot [2][3]

[2] http://www.strongtalk.org/history.html

[3] https://en.wikipedia.org/wiki/Strongtalk

Re:135M messages a second between processes in Java (2013) by robotresearcher on Sunday August 14, 2016 @12:36AM (#12284280)
'Worse is Better' is exactly about pragmatic reasons prevailing over idealism. The 'MIT Way' is the stereotyped opposite approach, and LISP is a great example of that: in theory it's the 'right way', but in practice it fails to address some aspect of real world needs somehow.
Re:135M messages a second between processes in Java (2013) by hota_mazi on Sunday August 14, 2016 @12:47AM (#12284303)
I understand that but I still dislike the "Worse is Better" characterization, which sounds very condescending to me and which is usually put forward by proponents of the languages that lost, hinting that the reason for the outcome is because people are stupid and picked the worse alternative.
Re:135M messages a second between processes in Java (2013) by robotresearcher on Sunday August 14, 2016 @01:51AM (#12284425)
Well, the originator was a 'losing' LISP guy who admired the robustness and practical effects of the other approach:

"However, I believe that worse-is-better, even in its strawman form, has better survival characteristics than the-right-thing, and that the New Jersey approach when used for software is a better approach than the MIT approach."

"There is a final benefit to worse-is-better. Because a New Jersey language and system are not really powerful enough to build complex monolithic software, large systems must be designed to reuse components. Therefore, a tradition of integration springs up."

Richard Gabriel https://www.jwz.org/doc/worse-is-better.html

Re:135M messages a second between processes in Java (2013) by pjmlp on Sunday August 14, 2016 @01:51AM (#12284424)
Looking at how Go has became successful, which is basically Java 1.0 or if you prefer Limbo merged with Oberon-2, it isn't very far from how people pick languages.

At least the amount of insecure C code decreases, as it gets written in a safer language

Re:135M messages a second between processes in Java (2013) by ww520 on Sunday August 14, 2016 @04:52AM (#12284854)
I remember Smalltalk and Lisp were pretty slow at the time and required tons of resources to run. Smalltalk and Lisp had better concepts but they fell short in delivering practical result.
Re:135M messages a second between processes in Java (2013) by varjag on Sunday August 14, 2016 @05:16AM (#12284938)
Java wasn't really light on resources at any point of its history either.
Re:135M messages a second between processes in Java (2013) by ww520 on Sunday August 14, 2016 @06:45AM (#12285106)
Java's resource requirement fitted pretty well within the hardware capability at the time, and grew with the hardware over time. Smalltalk and Lisp were quite ahead of their time requiring way more resource than the hardware could provide at the time.
Re:135M messages a second between processes in Java (2013) by varjag on Sunday August 14, 2016 @01:05PM (#12286327)
Ok which time are we talking about? In 1965, sure. In the times Java was actually around, it hardly had an edge against Common Lisp (can't comment on Smalltalk) implementations of the day by any resource metric. That's two and a half decades already.
Re:135M messages a second between processes in Java (2013) by sdegutis on Sunday August 14, 2016 @12:38AM (#12284285)
Why is nobody mentioning Clojure in this thread? I feel like Lisp kind of did win in the sense that Clojure is a reasonably sane Lisp that's gaining popularity and that lives on the JVM.
Re:135M messages a second between processes in Java (2013) by JBiserkov on Sunday August 14, 2016 @01:45AM (#12284415)
Not only is Clojure "a reasonably sane Lisp", it's a practical language that feels designed (because it is) using "power trough simplicity", decomposition, decompletion.

This frees up an enormous number of brain cycles to design the upper layers.

It embraces it's host (JVM, JavaScript) which enables tremendous reach and code-reuse; at the same time it fixes most WATs and subtler pitfalls (by using immutable, persistent data (structures) by default).

Re:135M messages a second between processes in Java (2013) by mateuszf on Sunday August 14, 2016 @02:36AM (#12284516)
If only the problems of slow startup and unfriendly error messages could be solved - it would be like a dream coming true.
Re:135M messages a second between processes in Java (2013) by soberhoff on Sunday August 14, 2016 @03:29AM (#12284633)
I think the spec library that they're putting together right now might be able to solve the error messages. What I'm waiting for is to be able to hit something like dot in my ide and see a list of suggestions, I'm not sure if spec can be leveraged to that extent.
Re:135M messages a second between processes in Java (2013) by swlkr on Sunday August 14, 2016 @01:01PM (#12286315)
Re:135M messages a second between processes in Java (2013) by soberhoff on Monday August 15, 2016 @02:45AM (#12289061)
Completing the first half of a symbol that I've been typing already works reasonably well with Cursive. What I'm looking for is something that looks at the result of an expression and figures out what other functions can accept that as input. Matching up specced postconditions with preconditions might work, but I'm not sure how well.
Re:135M messages a second between processes in Java (2013) by wtbob on Sunday August 14, 2016 @01:45PM (#12286522)
> I feel like Lisp kind of did win in the sense that Clojure is a reasonably sane Lisp that's gaining popularity and that lives on the JVM.

'Reasonably sane' is a matter of opinion. I really, really dislike Closure. I don't want to ban anyone from using it, but it really feels wrong to me. Far better to just use Lisp on the JVM, with a well-defined interface to Java.

Re:135M messages a second between processes in Java (2013) by StreamBright on Sunday August 14, 2016 @01:11PM (#12286356)
Because just like with many other things humans use the least common denominator wins. Everybody understands the concepts in Java pretty much but having trouble with LISP concepts. Just by interviewing ~40-50 Java programmers (mostly juniors) I can tell that even concepts like recursion is not well known or understood among them. At this level they think they do not need to know these advanced concepts to be successful as a software developer. As a company you want to use a language that everybody can understand so you do not have trouble with hiring, few exceptions (like Jane Street).
Re:135M messages a second between processes in Java (2013) by ww520 on Sunday August 14, 2016 @04:47AM (#12284838)
You asked a good question. And I hate to say it but that fact has driven a lot of people up the wall and they couldn't grasp how a language could win widespread adoption.
Re:135M messages a second between processes in Java (2013) by _asummers on Saturday August 13, 2016 @09:08PM (#12283844)
Java and the JVM are entirely separate beasts and should not be taken together. While most JVM code began as Java code, there are enough non-Java languages hosted on the JVM at this point that it should be looked at through the Java lens only.
Re:135M messages a second between processes in Java (2013) by desdiv on Sunday August 14, 2016 @02:45AM (#12284537)
>...that it should be looked at through the Java lens only.

I think you missed a "not" there.

Re:135M messages a second between processes in Java (2013) by _asummers on Sunday August 14, 2016 @02:08PM (#12286610)
I did indeed. Good catch!
Re:135M messages a second between processes in Java (2013) by hellofunk on Sunday August 14, 2016 @04:42AM (#12284823)
You should not confuse or conflate Java the language with Java the virtual machine. They really are quite distinct technologies.