optimizing-java | Code examples for `` Optimizing Java '' published by O'Reilly | Microservice library

Neither a monorepo as a concept nor Lerna as a tool are meant to do such kind of implicit "improvements". This may have unwanted side effects (for example if P1 and P2 depend on different versions of eosjs or where each package initiates an own instance of some package class).

Another reason speaking against doing what you are expecting here, is that packages in a monorepo still can be deployed independently from each other because they don't rely on the same reference of a package.

Utilizing a monorepo is as far as I know the only way to achieve what you are looking for. However, the monorepo just manages your codebase in one place. If you want to use the same reference of eosjs in both your packages, move it up into the root level package.json, but then you will also have to deal with a bunch of other problems that you might not expect yet. You can do it manually for your self-maintained monorepo packages or by hoisting for external packages with Lerna: https://github.com/lerna/lerna/blob/master/doc/hoist.md

Yarn Workspaces is what Lerna uses under the hood to achieve hoisting and might also help for understanding.

Webpack doesn't know about being in a monorepo unless you told it somehow, too. Its working independently of Lerna or monorepos.

Modification 1 won't work, because password will be set asynchronously, later, after do_login has returned.

Modification 2 doesn't work due to a typo; you have

It is more efficient because you're not running a bunch of assignment code within the constructor, that much should be obvious. It is sharing the same values on the prototype, as anything is shared on the prototype.

The thing is, when you read the value f1.prop1_, it looks up the value from the prototype chain since f1 itself doesn't have the property prop1_. But, when you assign to the property with f1.prop1_ = 5, it assigns directly to a property on the f1 object. In other words, assignment creates the property on the object itself. The prototype value is henceforth shadowed by the instance property. That's why instances will have separate values.

This is fine for immutable values; it's a bad idea for mutable values like arrays, since f1.arr_.push(foo) would mutate the object on the prototype instead of creating a property on the individual instance.

I realize there is a need to remove closures in the code to optimize the memory use.

For memory use, only the closures that you store somewhere count. When you get memory problems, you should check whether there are classes with lots of instances which each have their own closure instances. It does not mean that you should avoid closures in general.

One code pattern of mine is to use Array.forEach() as much as possible

Don't. Given that you are using ES6, you should be using for … of as much as possible (for imperative loops).

Apparently the callback function used in the Array.forEach() creates closures

Yes, but in the examples you've shown they're not avoidable (cannot be moved out into static functions). And given they last only as long as the forEach call and will be garbage-collected immediately after, there's no memory strain either.

However, as the article you linked explains, closures are still costly to create (compared to not creating them at all).

Should I go back to for loop in performance-sensitive projects?

Yes, definitely (at least in really performance-sensitive locations - no whole project will be). However the reason is not the cost of closures, it is the call overhead of functions in general that forEach cannot completely optimise.

Instance properties of reference types need to be added to the constructor otherwise when added to the prototype, each instance of the constructed object would share the same reference. It's OK when just reading information, but problem occurs when modyfing. Please check the following example