scripting language coexistence with static language

One:

Recently learned a clojure, very good, this let me think of a problem, the Java language is always said bad, where is the difference?

Yes, with Will Clojure, I also feel Java this language is very troublesome, everywhere is the pattern, very rigid feeling, but this kind of inflexible let project always have good engineering structure and so on.

From the directory structure to the syntax, it is a dead-end feeling, but this kind of dead can make the IDE very easy static parsing, can help you to find the most potential problems before you run the code.

I myself also thought, if uses the pure script language to write a big project, will later be very rotten? There is no static resolution to change a place, which other affected are not known.

A few lines of Perl code will make you feel good, it feels very creative, but give you 1K size Perl files you don't think so, after all, Perl is the only language that looks the same after RSA encryption .

Two:

Recently also saw Spring's spel, is a small script language which operates on the Java, uses the various assignment, this idea is very good, is uses the scripting language in the static language world to carry on the nimble operation.

Three:

One question recently: How high is the IQ of an octopus, and why some people say their IQ can rule the world? The answer is that the octopus has a brain of only 40% neurons, and the signal is a very high level of abstraction.
Four:

Looking back at the Java World, Maven Subdivides and manages a variety of different functional packages, which are like every command in Linux, a scripting language that can be used flexibly to implement some of our ideas or purposes.

Five:

One of the reasons Clojure chooses to implement on the JVM platform is not because the library is so much that it allows the Clojure program to write a lot less code and implement some functions.

Six:

Just like the brain of an octopus, to write a function, we just need to introduce a variety of packages, and then write an abstract high-level code on it. The question comes, what degree of abstraction is enough abstraction?

For the JSON lib, you give me a JSON string, give me a class, I return to your instance of this class, it is high enough, there is no other requirement.

But it is not enough for the projects we normally develop, but we still need to write a lot of code because those libraries are not written for our designated software, sacrificing part of the comfort to accommodate a wide range of requirements.

So after the software development, we can be in a variety of Java library based on a package, packaged into only a few parameters can be carried out in a certain area of the function of a large library.

Later, we can write simple scripts to manipulate those libraries.

Like analogy database CREATE TABLE XXX ... After that we can make various insert,update, then we can have the project support script def entity xx after the project is started ... Then you can update the various save.

There are a lot of company's workflow engines that are this pattern, and we can not just let the workflow support the script AH.

Package to a certain extent, software development can be like this:

The project starts up just like Linux starts up, just a platform, and then generates the configuration with a script before it generates the corresponding service.

Of course, this is not at the front end of this piece, there are too many interface uncertainties.

scripting language coexistence with static language