edwinnathaniel

I don't know what those sponsors do but I don't see any advancement in the Python world to be honest.

None of these companies decided one day to write the Spring Framework for Python (or the Rails). We got Django that seems stuck in 2005-2009... (no offense to Django devs).

Python runtime hasn't changed much...

Meanwhile in NodeJS land: - GoDaddy decided to re-write stuff using NodeJS - eBay adopting NodeJS in increasing pace - Progress (.com), legacy software company acquired modulus.io (NodeJS shop) - IBM z Systems supports NodeJS - Go to Microsoft Learning, you'll find lots of JavaScript tutorials (NodeJS or WinJS or Angular)

These companies promote NodeJS up-front. When Microsoft decided to hire people behind IronRuby and IronPython, I thought they decided to adopt those languages but that didn't last long before they cut them loose...

> Some people will point to language design characteristics, which are part of the story, but I think the deeper reason is that ruby does not have a serious corporate sponsor.

Spot on. Biggest reason why I don't think Ruby/Python will grow bigger than what they are today is this. Meanwhile NodeJS/JavaScript is adopted by _many_ companies: IBM, SAP, Google, Joyent, Microsoft, etc. Ruby had some momentum before but none of the big guys extend their support as far as NodeJS/JavaScript.

Having said that, I'd probably use Java for a new company , why not?

Some people say "bulb" I'd say "matured"

Some people say "verbose" I'd say "explicit than implicit" (or code is written once to be read multiple times)

Some people say "bloated framework" I'd say "stable and backward compatible without sacrificing speed and flexibility" or "does not have to reinvent my memory mental model" (compare to different JS API programming style).

Some think Maven "sucks/bloated" but I'd think nothing can touch it for the most part...(plus Maven's idea is copied everywhere else..)

To each of his/her own I suppose.

PS: I use JavaScript 100% to build 2 enterprise products as my day job

WA came out iPhone exclusive (then later on extended the offering to BB).

iPhone was hugely popular in North America. BB, on the other hand, is hugely popular in Asia (and probably Europe...?) that consists of 3 most populous countries: China, India, Indonesia... guess who uses WA the most...?

Support for other platforms came out very late...

Maven manage your module/projects from building, dependency management, generating project website (if you want to), deals with packaging, and deployment (if you want to), and many more (via plugins).

Maven is essentially NuGet+MSBuild or Ant+Ivy or Bundler+Gem+Rake without having to manage build tasks manually.

Those tasks are: 1. Compile code 2. Compile test code 3. Run unit-test 4. Run integration-test (separately from unit-test) 5. Setup paths for running unit-test (say you want to use different config/resource files for your unit-test) 6. Package your artifacts _without_ the unit-test artifacts

Maven has these built-in and in a non-disruptive manner. Don't have unit-tests? Maven won't run anything for you.

You have unit-tests source code and assets that you don't want to be included in your final build? Maven will handle that out-of-the-box-no-config needed.

While people might prefer to use "one tool that does its jobs beautifully/correctly", the reality is that you need at least 2 things to build the project: tool to manage your dependency and tool to build+package your project.

But then FAKE is just like MAKE which is just like MSBuild or ANT.

IMHO FAKE syntax is not for me.

.NET has F#, nice. JVM has Scala, JRuby, Clojure, etc. But that's a matter of taste/opinions.

> Will hard-core Linux users who used Java migrate when it makes sense?

Probably only for mobile/desktop app but less likely for back-end/webservice/infrastructure stuff.

Take MSBuild. This is pretty much Ant. Sure, there's NuGet but Ant+Ivy or MSBuild+NuGet combo isn't anywhere close to Maven (despite the XML hate).

Libraries, communities, tools, frameworks of .NET ecosystem is still behind Java.

Unfortunately language features and syntatic sugar alone probably not enough to sway these users. Besides, Java and C# are very similar, technically there's less reward in learning a very similar language.

Hear Hear.

My previous employer is in the field of network and application performance management. Even with unit-test, integration-test, and some functional-test, we can't be 100% sure we've covered everything (e.g.: different network setup) due to the domain complexity.

Having said that, "testing" has always been the biggest issue for any shop that call themselves "Agile" and it's also my screening test when interviewing with any company that claim themselves "agile": "let's talk about automation test..." :)

Decent JS IDE?

It's the best one I've tried out there. Literally. No other text-editor-with-plugins (VIM, Emacs, Sublime, Atom) or IDEs come anywhere close.

What if they _are not_ the best tool for the job largely because these tools just _get started_ (e.g.: v 0.1/0.2) and less mature?

Let's compare it with the evolution of Maven. Yes, I heard hatred and grumbling whenever Maven is mentioned but darn, that's a solid software. Old Maven, version 1 was OK, version 2 was solid, version 3 (or 4?) is when they address polishing issues and perhaps making a leap joining the new kids on the block (Gradle) by listening to the community and figure out a roadmap (I heard something about programmatically do stuff with Groovy... in Maven).

Sometimes one need to let the tools maturing and evolving before dropping judgement and roll yet-another-too-simple-tool and call it solving problems that the other tools did not do well (and for ego, of course, name a developer that has none..)

I went over those pages briefly and I wish it's not Selenium-like but it kinda is... :(

I think the right approach is to build from the ground up for testability both on unit-test and integration-test.

But one has to be very careful how to structure the pieces/components.

For example:

Do not write extensive unit-test on the UI but definitely have extensive Selenium tests for the UI _library_ (if you are a library builder). If you are a library user, assume the UI works as advertised and attaching/removing event-listener can be considered "configuration" type of code: test it once to see if it is configured properly and that's it!

If the SPA uses some sort of MVC/MVP, I'm hoping I can:

1. For unit-test

- unit-test individual M,V,C,P, Service, Helper, Model Validators, etc

- ability to mock different aspects

2. For integration-test

- ability to construct the whole thing (MVC/P) including the back-end, mock the View, and start controlling/simulating the code execution from the Controller/Presenter

The integration test can cover more than the unit-test to the point almost close to Selenium type of test but not as brittle as Selenium.

Can you briefly expand the e2e test aspect of Angular?

I'm looking to learn ways to do e2e test without touching the DOM (e.g.: from Controller all the way up to the back-end; imagine firing up Chrome DevTools console and start writing JS code that executes some logic and eventually fires AJAX request and process the response, of course in this case the View will be mocked but the app logic and everything else can be executed).

That's not quite correct.

I've had good success in architecting/designing classical web-app (MVC-ish as overall architecture and minimum JS on front-end).

I can write unit-test with mocking and integration-test with in-memory database as part of my build/compile loop.

But I struggled a lot with front-end.

I'm also interested to see a mid-size scale SPA project that has excellent unit-testing and integration-testing.

I've read a lot about how JS can make programmer productive, I've also read a lot how code can be succinct and all that jazz because of JS, but I have _never seen_ a well-architected, well-documented, well-automated-tested non-todomvc SPA codebase.

This isn't a sarcasm or criticism but a serious and legitimate "ASK" because I'm working on a large-scale SPA project that's hard to write automation test other than Selenium.

I'm looking for something that can taught me:

1. Unit-testing (with some level of mocking)

2. Integration-testing (testing various components without hitting the UI but all the way up to the sending request, kind of like driving the front-end code without the UI).

3. Best practices/patterns for architecting large-scale SPA (hint: generic EventBus tend to be abused).

Probably it's heading toward where niche ecosystem/platform is today: Haskell, Erlang. But with less uptake because the similar audiences/users of those platforms are less likely to touch Microsoft... (even if they're reaching cross-platforms)

Anyone using SAP HANA for Series Data?

Perhaps to avoid the same situation with FB Messenger Erlang to C++ conversion? What do you think?

I learned a few things from this post outside the usual "technical" explanations:

1. They have CORE Haskell contributors on their payroll to deliver this type of project (what this mean is that no... Haskell isn't any better than other language, it's just that they have people who know Haskell very very deep to the compiler level...)

2. In-house custom language eventually does not scale (the EOL is much much much shorter than other programming languages), plan for that :)

MVP _is_ huge (probably de-facto pattern) in the Google WebToolkit community.

The way I see it is this: MVC works for Widget level (imagine a Swing component: JTable or something, there's the table rendering => View, the table data => Model, the table event processing/logic => Controller). But you need a higher-level architecture that controls everything in the app and that's where MVP comes in.

There's no framework per-se in GWT because MVP is so easy to implement.

View v = new ViewImpl(); // usually View is an interface or you can mock it...

Service s = new ServiceImpl(); // usually Service is an interface, or you can mock it...

Presenter p = new Presenter(service, view, models);

// in constructor

v.addListener(new Listener(){ public void execute(){ p.processData(); };});

p.getData(); // potentially calls service ajax request

p.persist(); // calls s.persist(model);

p.processData(); // potentially called by the event listener from the view, say user press a button

The idea of MVP is to be able to write unit-test (against the Presenter) that does not touch the widget level but able to cover everything else. Attaching a listener to ensure a code will be executed is considered "configuration".

This MVP style differs to the one mentioned in the Ezra blog where the model calls Repository/Service. This MVP styles makes it explicit for Presenter to orchestrate the Model, View, and Service interaction. No two way binding or implicit stuff.

> The syntax is annoying

That's a matter of perspective no? I'm not fond of symbols so reading Ruby super-terse code makes me choose watching a movie on Netflix over that.

> The ecosystem on the other hand can be totally befuddling

You mean slightly better than Python that keeps re-inventing the (half) wheel? :D

Maven is used by the majority projects with Android projects as an exception because Google pushed hard for Gradle.

For DI frameworks: Spring is the majority winner with Guice/CDI on the second place.

Apache vs Google Guava only because Guava came in late and both are just a nice small library (not a framework). Older code within the codebase might have already used Apache Common lib and newer code within the _same_ codebase will more likely use Guava where it is fit (I/O is an area where Apache has better library).

We should also compare this situation with various Auth & Auth lib for Rails/NodeJS project :).

So shrug ... Java has been around longer, at most usually there are 2 competing libraries for certain area and the better ones tend to win (again, depend on your perspective what "better" means: some prefer Maven over Gradle).

Isn't that the same with _any_ ecosystem?

Ruby => Rails (most of the time...) Python => Django NodeJS => ExpressJS

Ruby => RubyGems + Rake + Bundler Python => (finally something ... static) pip NodeJS => NPM Browser JS => Bower

NodeJS tries to be as simple as possible but at the end of the day, you need to use/download/learn libraries with different quality/documentation level and different API-feel/code-style.

Was going to say this....

Magic Johnson has tons of businesses, connections, and especially urban markets.

JavaScript the Good Parts shouldn't be the recommended book anymore (and I think even Crockford himself said something along that line in one of his newer videos, couldn't find it though... it's been a while)

Dynamics CRM approaching $2B and the Head is cut... :(

Startups, Web-Design boutique/consulting, freelance/contract. Less likely the big guys (Google, MS, Apple, Amazon).

If anyone wants to have similar end-user performance monitoring, AppNeta has the solution for you: http://www.appneta.com/blog/rum-vs-synthetic/

They have both RUM (requires injecting 3rd-party script, in this case, AppNeta)) and Synthetic (does not require any modification of your client-side artifacts).

Disclaimer: I used to work on the Synthetic side.

Java IDE of course. Not the number of characters on the screen.

I don't know about you but my experience with Java required me to type either the same or less than JS if we are comparing apple vs apple, not simple front end vs complicated back end.

It's no longer "if".

It has becoming a reality slowly...

Choosing Java over Ruby/Python for your web-app really depends on what you want to sacrifice.

I counted LISP out because unless you're using Clojure, I know for sure you're not going to be able to beat anything else for web-app development. LISP for web-app probably works in the 90's for PG but we're in 2015 where libraries, frameworks, and tools for these other languages are just far too advanced and more productive than writing macros... sorry mate.

Anyway, back to Java over Ruby/Python.

Take a few examples:

At the Microservice area, Java seems to shine over other languages/platforms. JAX-RS feels more complete than Sinatra or whatever Django plugins that the Python community use. See a quick example of JAX-RS vs Sinatra somewhere in this blog post: (http://www.appneta.com/blog/microservice-service-oriented-ar...)

Maven can be huge and underwhelming (and ugly once in a while) but it's definitely more powerful than gems+bundler+rake and whatever Python adopts these days. Maven has been around for a while so most Java DEVs don't have to pick up tools as Python DEVs have to do quite often. But again, there are trade-offs: Maven XML is definitely uglier than Bundler or requirements.txt or package.json.

Let me ask one thing: in platform other than Java, do you use declarative transaction? My guess is "No". Which means you have to know when to open and close a transaction (and potentially join an existing one if the library isn't smart enough). Java Spring/EJB provides annotation based transaction.

I'm not suggesting that Java is better than other languages, but there are advantages of choosing Java.