Category Archives: Scripting

Regular Expressions For Regular Work

Time and again I saved a lot of time for the company I work for, the group I am part of and to myself by writing simple scripts. These scripts were written in sh/tcsh/bash, sed, awk and perl. One thing common in almost all these scripts is the usage of regular expressions either to parse the files or to get the list of files to process.

One of my favorite pattern is

find . -name 'some-regex-pattern' -print | xarg -iFILE some-shell-command

What this does is, recursively gets the list of all files from a directory that match a particular regular expression pattern and then make them available as a FILE variable and execute some shell command that contains FILE word which gets substituted with the actual file.

For any aspiring developer learning and Mastering Regular Expressions is very important. Infact, even as a development manager who needs to often analyze a set of existing files to decide on a project like introducing changes across the entire set of files or determining design change impact etc can be easily done using the regular expressions.

The book Mastering Regular Expressions is supposed to be one of the best books for learning regular expressions.

Leave a comment

Filed under Programming, Scripting, Tech Books

Rules Engine or Scripting Engine?

The question is which approach is better? The initial thought/requirement is that business users should be able to quickly adopt to changes in business and so, the rules engine provides them an easy way to quickly modify the business logic. But if only the business logic is so simple that one can simply change from + to – (markup vs discount). Those simple if then else rules soon become complex statements, blocks, built-in functions and soon a whole set of new language emerges and no longer in the reach of the business user to write them.

Perhaps when the scripting was not popular/well explored and thanks to the hype of AI in the earlier decades, the concept of rules engine came into existence. But with a better undersanding of scripting languages and the ability make them co-exist with compiled languages (c + tcl, java + beanshell a few examples), are rules engines lucrative anymore?

Yes, I do understand there is farward chaining, backward chaining, hybrid chaining and all that stuff and for that there are languages such as Prolog and Lisp that are very good at. But, deductive reasoning shouldn’t be confused with much of the business rules. I mean, it’s not like much of the auto-insurance policy rules have to go through a 10-level deep tree with 1000s of nodes before finding a solution. Or is it? I could be wrong, but hope not. Otherwise, it will be hard for me to compare and get the best deal :). So, I am not talking about knowledge based expert system type of rules engines.

I think the main issue is, going with hard-coded logic, it’s possible to do very complicated and optimized logic. Going with simple rules engines that are easy enough for business users, a few simple cases, perhaps even 70% of cases can be solved. But what about the rest? It’s the in-between cases that cause the problem. So, going with business rules perhaps is going to leave a gap.

However, using an embedded scripting engine, it’s probably possible to address the needs of both simple and medium complex problems. Infact, it may be possible to solve even the most complex problems, albiet a little slower (performance and not coding).

Frankly, if someone is telling that a business guy would know to write excel type of functions and branching logic such as IF(a,b,c), and can’t understand if(a) then b else c; then there is something fundamentally wrong in that assumption. I think it’s not the simple syntax that is the problem, but the overall logic of the code that makes it difficult.
And especially, if the data for the logic is in the database, the seamless way of fetching the necessary data, the sqls, the transaction and commits, in memory data vs database data and so on. These are the things that make things more complex, and not the simple syntax of rules.

All said and done about rules, Oracle 10g has an interesting rules engine that is event based. Pretty cool stuff and has more practical use than what conventional rules engines or programs can offer.

Those interested in scripting languages can further explore with these scripting languages books.

Leave a comment

Filed under Database, Questions, rules engine, Scripting