Tuesday, October 21, 2008
Business Rules Engine - BRE
Business rules the operations, definitions and constraints that apply to an organization in achieving its goals. Simply put Business rules represent the Decision making policies of an organization like All customers that spend more than $100 at one time will receive a 10% discount.
Business rules represent a natural step in the application of computer technology aimed at enhancing productivity in the workplace. Automated business processes that have business logic embedded inside often take substantial time to change, and such changes can be prone to errors. And in a world where the life cycle of business models has greatly shortened, it has become increasingly critical to be able to adapt to changes in external environments promptly. These needs are addressed by a business rules approach.
Business rules enhances Business Agility. And the manageability of business processes also increases as rules becomes more accessible.
A BRMS or Business Rule Management System is a software system used to define, deploy, execute, monitor and maintain the variety and complexity of decision logic that is used by operational systems within an organization or enterprise. This logic, also referred to as business rules, includes policies, requirements, and conditional statements that are used to determine the tactical actions that take place in applications and systems.
A BRMS includes, at minimum:
* A repository, allowing decision logic to be externalized from core application code
* Tools, allowing both technical developers and business experts to define and manage decision logic
* A runtime environment, allowing applications to invoke decision logic managed within the BRMS and execute it using a business rules engine
The top benefits of a BRMS include:
* Reduced or removed reliance on IT departments for changes in live systems
* Increased control over implemented decision logic for compliance and better business management
* The ability to express decision logic with increased precision, using a business vocabulary syntax and graphical rule representations (decision tables, trees, scorecards and flows)
* Improved efficiency of processes through increased decision automation
* Rules are externalized and easily shared among multiple applications
Then how it is designed ???
Many organizations' rules efforts combine aspects of what is generally considered work-flow design with traditional rule design. This failure to separate the two approaches can lead to problems with the ability to re-use and control both business rules and workflows. Design approaches that avoid this quandary separate the role of business rules and work flows as follows:
Business rules produce knowledge (~=data) ; work flows perform business work (~=function). Concretely, that means that a business rule may do things like detect that a business situation has occurred and raise a business event (typically carried via a messaging infrastructure) or create higher level business knowledge (e.g., evaluating the series of organizational, product, and regulatory-based rules concerning whether or not a loan meets underwriting criteria). On the other hand, a work flow would respond to an event that indicated something such as the overloading of a routing point by initiating a series of activities.
This separation is important because the same business judgment (mortgage meets underwriting criteria) or business event (router is overloaded) can be reacted to by many different work flows. Embedding the work done in response to rule-driven knowledge creation into the rule itself greatly reduces the ability of business rules to be reused across an organization because it makes them work-flow specific.
To deliver this type of architecture it is essential to establish the integration between a BPM (Business Process Management) and BRM (Business Rules Management) platform that is based upon processes responding to events or examining business judgments that are defined by business rules. There are some products in the marketplace that provide this integration natively. In other situations this type of abstraction and integration will have to be developed within a particular project or organization.
Most Java-based rules engines provide a technical call-level interface, based on the JSR-94 application programming interface (API) standard, in order to allow for integration with different applications, and many rule engines allow for service-oriented integrations through Web-based standards such as WSDL and SOAP.
Most rule engines supply the ability to develop a data abstraction that represents the business entities and relationships that rules should be written against. This business entity model can typically be populated from a variety of sources including XML, POJOs, flat files, etc. There is no standard language for writing the rules themselves. Many engines use a Java-like syntax, while some allow the definition of custom business friendly languages.
Most rules engines function as a callable library. However, it is becoming more popular for them to run as a generic process akin to the way that RDBMSs behave. Most engines treat rules as a configuration to be loaded into their process instance, although some are actually code generators for the whole rule execution instance and others allow the user to choose
Types of rule engines
There are two different classes of rule engines, both of which are usually forward chaining. The first class processes so-called production/inference rules. These types of rules are used to represent behaviors of the type IF condition THEN action. For example, such a rule could answer the question: "Should this customer be allowed a mortgage?" by executing rules of the form "IF some-condition THEN allow-customer-a-mortgage".
The other type of rule engine processes so-called reaction/Event Condition Action rules. The reactive rule engines detect and react to incoming events and process event patterns. For example, a reactive rule engine could be used to alert a manager when certain items are out of stock.
The biggest difference between these types is that production rule engines execute when a user or application invokes them, usually in a stateless manner. A reactive rule engine reacts automatically when events occur, usually in a stateful manner. Many (and indeed most) popular commercial rule engines have both production and reaction rule capabilities, although they might emphasize one class over another. For example, most business rules engines are primarily production rules engines, whereas Complex Event Processing rules engines emphasize reaction rules
In computer science, and specifically the branches of knowledge engineering and artificial intelligence, an inference engine is a computer program that tries to derive answers from a knowledge base. It is the "brain" that expert systems use to reason about the information in the knowledge base for the ultimate purpose of formulating new conclusions. Inference engines are considered to be a special case of reasoning engines, which can use more general methods of reasoning.
Inference Engine - Architecture
The separation of inference engines as a distinct software component stems from the typical production system architecture. This architecture relies on a data store, or working memory, serving as a global database of symbols representing facts or assertions about the problem; on a set of rules which constitute the program, stored in a rule memory of production memory; and on an inference engine, required to execute the rules. (Executing rules is also referred to as firing rules.) The inference engine must determine which rules are relevant to a given data store configuration and choose which one(s) to apply. The control strategy used to select rules is often called conflict resolution.
An inference engine has three main elements. They are:
1. An interpreter. The interpreter executes the chosen agenda items by applying the corresponding base rules.
2. A scheduler. The scheduler maintains control over the agenda by estimating the effects of applying inference rules in light of item priorities or other criteria on the agenda.
3. A consistency enforcer. The consistency enforcer attempts to maintain a consistent representation of the emerging solution.
The recognize-act cycle
The inference engine can be described as a form of finite state machine with a cycle consisting of three action states: match rules, select rules, and execute rules.
In the first state, match rules, the inference engine finds all of the rules that are satisfied by the current contents of the data store. When rules are in the typical condition-action form, this means testing the conditions against the working memory. The rule matchings that are found are all candidates for execution: they are collectively referred to as the conflict set. Note that the same rule may appear several times in the conflict set if it matches different subsets of data items. The pair of a rule and a subset of matching data items is called an instantiation of the rule.
In many applications, where large volume of data are concerned and/or when performance time considerations are critical, the computation of the conflict set is a non-trivial problem. Earlier research work on inference engines focused on better algorithms for matching rules to data. The Rete algorithm, developed by Charles Forgy, is an example of such a matching algorithm; it was used in the OPS series of production system languages. Daniel P. Miranker later improved on Rete with another algorithm, TREAT, which combined it with optimization techniques derived from relational database systems.
The inference engine then passes along the conflict set to the second state, select rules. In this state, the inference engine applies some selection strategy to determine which rules will actually be executed. The selection strategy can be hard-coded into the engine or may be specified as part of the model. In the larger context of AI, these selection strategies as often referred to as heuristics following Allen Newell's Unified theory of cognition.
In OPS5, for instance, a choice of two conflict resolution strategies is presented to the programmer. The LEX strategy orders instantiations on the basis of recency of the time tags attached to their data items. Instantiations with data items having recently matched rules in previous cycles are considered with higher priority. Within this ordering, instantiations are further sorted on the complexity of the conditions in the rule. The other strategy, MEA, puts special emphasis on the recency of working memory elements that match the first condition of the rule. (The latter heuristic is heavily used in means-ends analysis.)
Finally the selected instantiations are passed over to the third state, execute rules. The inference engine executes or fires the selected rules, with the instantiation's data items as parameters. Usually the actions in the right-hand side of a rule change the data store, but they may also trigger further processing outside of the inference engine (interacting with users through a graphical user interface or calling local or remote programs, for instance). Since the data store is usually updated by firing rules, a different set of rules will match during the next cycle after these actions are performed.
The inference engine then cycles back to the first state and is ready to start over again. This control mechanism is referred to as the recognize-act cycle. The inference engine stops either on a given number of cycles, controlled by the operator, or on a quiescent state of the data store when no rules match the data.
Data-driven computation versus procedural control
The inference engine control is based on the frequent reevaluation of the data store states, not on any static control structure of the program. The computation is often qualified as data-driven or pattern-directed in contrast to the more traditional procedural control. Rules can communicate with one another only by way of the data, whereas in traditional programming languages procedures and functions explicitly call one another. Unlike instructions, rules are not executed sequentially and it is not always possible to determine through inspection of a set of rules which rule will be executed first or cause the inference engine to terminate.
In contrast to a procedural computation, in which knowledge about the problem domain is mixed in with instructions about the flow of control—although object-oriented programming languages mitigate this entanglement—the inference engine model allows a more complete separation of the knowledge (in the rules) from the control (the inference engine).
** All the content on this blog is extracted from various sources. I just trying understand and present them in my own fashion. Some times if i feel original thing itself as good, i am producing it as it is. Hence all credit goes to the original content writers...
Business Process Management - BPM
2. Operational processes: These are the processes that constitute the core business and create the primary value stream. Typical operational processes are Purchasing, Manufacturing, Marketing, and Sales.
3. Supporting processes: These are the processes to support the core processes.
Examples include Accounting, Recruitment, Technical support.
A business process can be decomposed into several sub-processes, which have their own attributes, but also contribute to achieving the goal of the super-process. The analysis of business processes typically includes the mapping of processes and sub-processes down to activity level. Activity is the smallest level of individual work that can be done in an organization.
Business Processes are designed to add value for the customer and should not include unnecessary activities. The outcome of a well designed business process is increased effectiveness (value for the customer) and increased efficiency (less costs for the company).
A business process begins with a customer’s need and ends with a customer’s need fulfillment.
So then What is BPMS ??
Yaaa.. it is what DBMS for DB to Business Process :-) .
Don't worry ..... BPMS is the software wrap around these processes to manage them properly.
oooh Then how it manages ??
It's a 5 step process (Lets call it Life cycle)
design, modeling, execution, monitoring, and optimization.
Lets see what they do individually
Design

Process Design encompasses both the identification of existing processes and designing the "to-be" process. Areas of focus include: representation of the process flow, the actors within it, alerts & notifications, escalations, Standard Operating Procedures, Service Level Agreements, and task hand-over mechanisms.
Good design reduces the number of problems over the lifetime of the process. Whether or not existing processes are considered, the aim of this step is to ensure that a correct and efficient theoretical design is prepared.
Modelling
Determines how the process that we considered in Design phase might operate under different circumstances like What if I have 75% of resources to do the same task? What if I want to do the same job for 80% of the current cost? Etc.,
Execution
Automating a process definition requires flexible and comprehensive infrastructure which typically rules out implementing these systems in a legacy IT environment. Here BRE seems to be a good option. Because Business rules have been used by systems to provide definitions for governing behavior, and a business rule engine can be used to drive process execution and resolution.
Monitoring
Monitoring encompasses the tracking of individual processes so that information on their state can be easily seen and statistics on the performance of one or more processes provided. An example of the tracking is being able to determine the state of a customer order (e.g. ordered arrived, awaiting delivery, invoice paid) so that problems in its operation can be identified and corrected
Process mining is an interesting area to look forward here. It is something like applying Data mining techniques to Process data. The aim of process mining is to analyze event logs extracted through process monitoring and to compare them with an 'a priori' process model. Process mining allows process analysts to detect discrepancies between the actual process execution and the a priori model as well as to analyze bottlenecks.
Optimization
Process optimization includes retrieving process performance information from modeling or monitoring phase and identifying the potential or actual bottlenecks and potential rooms for cost savings or other improvements and then applying those enhancements in the design of the process thus continuing the value cycle of business process management
Thursday, October 16, 2008
Intro 2 PEGA PRPC

Hi,
I am going to present something i known about PEGA PRPC (Pega Rule Process Commander).
Let get into some technical jargon....

Personalization through Rules Resolution
o Interfaces to Crystal Reports, MS Word and Excel
o Customization of development environment
Deployment Features:
o Push or pull changes to production with advanced deployment support through rule set
management and versioning
o Distribution support for applications developed with Process Commander
Application Changes and Updates:
o Changes to business logic via changes to business rules in real time
o Changes to business process flows via changes to Visio flow diagrams in real time
o Built-in Version Management
o Robust enterprise versioning enabling scaling to 100,000 rules and processes
o No database schema changes required to add properties or objects
Web Services:
o Wizard-based Web Services set up; three times faster than Java IDE
o Support for SOAP, IBM’s MQ Series, COM and XML
• Security:
o Role-based security

But as developer/programmer, i am a little bit biased towards cording work, which you find very minimal in PRPC based development work. I am personally feeling that without coding, we can't improve our analysis and problem solving skills. Ofcourse, its my personal opinion only.
Luckily, we have a devision here which will take part in PEGA product development itself which will work in tight integration with PEGA india team.
Lets hope i will get into that team, so that i will take responsibility of doing the magic behind scenes rather than again and again re-using the features developed by someone else. Why should i miss the fun........ :-)
As a developer i don't recommend to work as PEGA PRPC developer but from organizations and clients profits point of view it is highly recommended. If you want money, go and get trained on PRPC, there is a highly demanding skill. If you want coding satisfaction look into java/J2EE space.
Right now i don't have any choice... i have to work in accordance of my organizations goals. ;-)
The biggest hurdle infront of me is to master this Technology. I personally feel there are no resources available for it on the web and the PEGA's PDN is not that much sufficient. Until now i am finding it very difficult to learn it. The manuals and Online Help PEGA is providing is giving one procedure to achieve something. But in that procedure if any thing goes wrong we don't know what went wrong and how to fix it. Just because we don't know what is happening behind the scenes. Understanding the internals is not recommended for every PRPC developer and even if you desired for it, there is no way you can do it unless you worked in a PEGA Product development environment. Right now i am collecting bits and peaces to get out of the hurdles i am facing with the help of seniors and in tern i want to share it globally.
So i am decided to publish some of the "technical how-tos" in the way i understand them.
Keep watching this space.....
Monday, October 13, 2008
Reading Excel sheet using java
As part of my current project requirement, i have to read an excel file and store that one into a Database.
Lets see how i did it and that may save you some time.
First thing that comes into picture is how to read Excel without using any Third party tools. Licensing is a big problem. So we have to achieve it using native JDK support. We can achieve this by considering the EXCEL document as a database file. To connect to this DB, we need to use the Microsoft provided Excel Database Drivers. (we can found them in Control panel --> Administrative Tools --> ODBC Data Source Administrator. Click Add and find the Microsoft Excel Driver (*xls))
Use the appropriate DNS name (say ExcelDNS) and select the workbook (say ExcelFile).
Remaining everything is similar to connecting to Other DBs.
Here is the Sample Code for it
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package japp;
import java.io.*;
import java.sql.*;
/**
*
* @author TBalakrishna
*/
public class ExcelToJava
{
public static void main(String[] args)
{
Connection connection = null;
try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
Connection con = DriverManager.getConnection( "jdbc:odbc:ExcelDNS" );
Statement st = con.createStatement();
ResultSet rs = st.executeQuery( "Select * from [Sheet1$]" );
ResultSetMetaData rsmd = rs.getMetaData();
int numberOfColumns = rsmd.getColumnCount();
//Remember First column will be treated as a Heading. So it can't be considered for printing
while (rs.next())
{
for (int i = 1; i <= numberOfColumns; i++) { if (i > 1) System.out.print(", ");
String columnValue = rs.getString(i);
System.out.print(columnValue);
}
System.out.println("");
}
st.close();
con.close();
}
catch(Exception ex)
{
System.err.print("Exception: ");
System.err.println(ex.getMessage());
}
}
}
----------------------------------------------------------------------------------------------
Upto now everything seems fine. But it has its own downsides... Like it can be implemented only on Windows Servers (i need Microsoft Excel Drivers .. right ;-)
So i thought of some other api's that i can use with out MS-Win dependency. Here are some those APIs
Library / package | License | Description |
---|---|---|
Actuate Spreadsheet Engine | Commercial, 30-day trial version available | Write Excel (XLS) files. |
ExcelAccessor | ? | Read and write Excel (XLS) files. |
ExcelReader | ? | JavaWorld article on how to read Microsoft Excel (XLS) files, including code. Requires an installed Microsoft ODBC driver for Excel files, and Sun's ODBC-JDBC driver. |
ExtenXLS | Commercial, 30-day trial version available | Read and write Microsoft Excel (XLS) files. |
JACOB project | LGPL | Java COM bridge with examples to interface Excel. |
Java Excel API | LGPL | Read Excel (XLS) 97, 98 and 2000 files. |
Java to Excel conversion | ? | Write SYLK files, which Excel can import and export. |
JExcel | Commercial | Swing component to integrate Excel via JNI. |
jXLS | LGPL | Create Excel files using XLS templates. |
POI | Apache Software License 1.1 | Read and write Microsoft OLE 2 compound document format files. This includes MS Office files (DOC, XLS, PPT) written with Office versions that were released after 1997. |
Snowbound | Commercial | Read Excel files. |
SoftArtisans OfficeWriter | Commercial | Write Word and Excel files. |
Vista JDBC | Commercial, 15-day trial version available | JDBC driver to access MS Excel (XLS) files. |
xlSQL | GPL | JDBC driver to access MS Excel (XLS) and CSV files. |
The structure of this File System is
The following is the top-level structure of an Excel Workbook:
Example.xls {
OLE2CDF headers
"Workbook" stream {
Workbook {
Static String Table Record..
Sheet names... and pointers
}
Sheet {
ROW
ROW
...
NUMBER RECORD (cell)
LABELSST Record (cell)
...
}
Sheet
}
}
... images, macros, etc.
Document Summary
Summary
Java Excel API which is developed by Sourceforge.net (my favorite open source resource) looks to be an option. You can find about it @ http://jexcelapi.sourceforge.net/
download jxl.jar to you classpath. Here is the code to read an Excel file named ExcelSheet.xls
import java.io.File;
import java.io.IOException;
import jxl.*;
import jxl.read.biff.BiffException;
import jxl.write.*;
public class ReadExcel
{
private String inputFile;
public void setInputFile(String inputFile)
{
this.inputFile = inputFile;
}
public void read() throws IOException, WriteException
{
File inputWorkbook = new File(inputFile);
Workbook w;
try {
w = Workbook.getWorkbook(inputWorkbook);
// To get First sheet use 0 else what ever the number you want.
Sheet sheet = w.getSheet(0);
// Column wise reading for all rows
for (int j = 0; j <>
for (int i = 0; i <>
Cell cell = sheet.getCell(j, i);
CellType type = cell.getType();
//If its a LABEL
if (cell.getType() == CellType.LABEL)
{
System.out.println("I got a label "+ cell.getContents());
}
//If its a NUMBER
if (cell.getType() == CellType.NUMBER)
{
System.out.println("I got a number "+ cell.getContents());
}
//Like there there are a lot of Types. Better you use an switch here
}
}
} catch (BiffException e)
{
e.printStackTrace();
}
}
public static void main(String[] args) throws WriteException, IOException
{
ReadExcel test = new ReadExcel();
test.setInputFile("c:/temp/ExcelSheet.xls");
test.read();
}
}
------------------------------------------------------------------------------------------------
Next one is to use APACHE POI
Apache's POI (Poor Obfuscation Implementation, the name that seemed to describe the format best) is a high-quality application that can read and write Excel and other MS-format files right from inside of your Java application
POI consists of various parts that fit together to deliver the data in a MS file format to the Java application. At the lowest level is the POIFS (POI FileSystem) API that contains the basic logic to process any OLE2CDF file. Above that sit the various components to process the application data. HSSF (Horrible SpreadSheet Format) understands the Excel structures, while HDF (Horrible Document Format) understands the Microsoft Word structures. In this article, we will look at how to use POIFS to read or write a OLE2CDF file. In future articles of this series, we shall see how to use HSSF and HDF, as well as HPSF (Horrible Property Sheet Format, used to read -- and eventually write -- document property information available through File->Property) and using the HSSF Cocoon Serializer to serialize XML to an Excel file.
Microsoft's OLE 2 Compound Document format once prevented Java programmers from reading and writing Office and MFC-generated file formats from pure Java. Java programmers often had to resort to native bridges which limited them to Microsoft Operating Systems. The Jakarta POI Project opens up new worlds to Java developers by allowing them to write to OLE2CDF-based file formats with pure Java -- even on UNIX. This article explained how to work with the underlying OLE 2 Compound Document Format. In the next article, we'll explain how to read, write, and Modify Excel files with HSSF. The final article will cover the HSSFSerializer for Cocoon, as well as HPSF and HDF.
HSSF has two APIs for reading: usermodel and eventusermodel. The former is most familiar, and the latter is more cryptic but far more efficient. The usermodel consists primarily of the classes in the org.apache.poi.hssf.usermodel package, as well as org.apache.poi.hssf.eventusermodel. (In earlier versions of HSSF, this was in the eventmodel package.) The usermodel package maps the file into familiar structures like Workbook, Sheet, Row, and Cell. It stores the entire structure in memory as a set of objects. The eventusermodel package requires you to become more familiar with the actual low-level structures of the file format. It operates in a manner similar to XML's SAX APIs or the AWT event model (the origin of the name)--and can be trickier to use. It is also read-only, so you cannot modify files using the eventusermodel
Reading Excel sheet using Apache's POI
import java.io.IOException;
import java.io.InputStream;
import java.util.Iterator;
import org.apache.poi.poifs.filesystem.POIFSFileSystem;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.hssf.usermodel.HSSFRow;
/**
* A simple POI example of opening an Excel spreadsheet
* and writing its contents to the command line.
* @author Tony Sintes
*/
public class POIExample {
public static void main( String [] args ) {
try {
InputStream input = POIExample.class.getResourceAsStream( "qa.xls" );
POIFSFileSystem fs = new POIFSFileSystem( input );
HSSFWorkbook wb = new HSSFWorkbook(fs);
HSSFSheet sheet = wb.getSheetAt(0);
// Iterate over each row in the sheet
Iterator rows = sheet.rowIterator();
while( rows.hasNext() ) {
HSSFRow row = (HSSFRow) rows.next();
System.out.println( "Row #" + row.getRowNum() );
// Iterate over each cell in the row and print out the cell's content
Iterator cells = row.cellIterator();
while( cells.hasNext() ) {
HSSFCell cell = (HSSFCell) cells.next();
System.out.println( "Cell #" + cell.getCellNum() );
switch ( cell.getCellType() ) {
case HSSFCell.CELL_TYPE_NUMERIC:
System.out.println( cell.getNumericCellValue() );
break;
case HSSFCell.CELL_TYPE_STRING:
System.out.println( cell.getStringCellValue() );
break;
default:
System.out.println( "unsuported sell type" );
break;
}
}
}
} catch ( IOException ex ) {
ex.printStackTrace();
}
}
}
------------------------------------------------------------------------------------------------
Remember
getPhysicalNumberOfRows() returns the physical number of rows which may be more than the actual (logical) number of rows. The same goes for getPhysicalNumberOfCells().
You should check for nulls when fetching the HSSFRow and HSSFCell objects as shown.
Remember that Excel tables are often sparsely populated. So choose your data structures accordingly. POI accesses the data by sheet. In JExcelAPI you can directly access the data in any row and column
-------------------------------------------------------------------------------------------------
Conclusion
Comparison of JExcelAPI with Jakarta-POI (HSSF)
1. JExcelAPI is clearly not suitable for important data. It fails to read several files. Even when it reads it fails on cells for unknown reasons. In short JExcelAPI isn't suitable for enterprise use.
2. HSSF is the POI Project's pure Java implementation of the Excel '97(-2002) file format. It is a mature product and was able to correctly and effortlessly read excel data generated from various sources, including non-MS Excel products like Open Office, and for various versions of Excel. It is very robust and well featured. Highly recommended
Tuesday, August 26, 2008
Why Chiru?
One of my friend raised an objection here saying that " being in-experienced politican how its going to be a great qualification and do you thinking that all current politicans are bad"
i am accepting his comments and removing a few words from my article....
He is a new comer into this field, so by the time he learns how to do all these things, it will take some time. As a fresher, he will may try to do some thing good for till he get defeated.
By the track record of Chiru, i don't think, he will get defeated. Just because he became No.1 in a field which similarly ruled on the base of caste. But he conquered it not just with Charishma and acting. He know how to win.
Another comment is how chiru's past track record in Movie field will guarentee success in completely different "Political field".
It as simple as on what basis a student is get into IITs based on his performance in IIT-JEE. In IIT-JEE, he will be tested on Intermediate subjects and going to study enginnering (which branch doesn't mind).
Its the basic characterists like commitment and hardworkingness are the stepping stones to success in every field. There is no other short cut to success.
After seeing his accomplishments and service motiveness towards society even before getting into power. I beleiving that, there is nothing wrong in giving him an opportunity.
If any one contradicts, tell who else i have to cast my vote and why?
Y.S.R is one of the bledy damn politician
1. with in one year after coming into power, most of key opposition leader are murdered. Through this, he started a new tradition. Now if TDP comes into power, obviously they too will do the same. With this Y.S.R. proved that he is the first class Faction politician and started a new tradition in AP politics.
From this point of view, i appreciate ChandraBabu. Upto now he never practiced it. But can't guarente about the feature. He may be not interested in doing these things. But to satisfy their cadre he may have to allow them what they want.
2. He Divided and started Ruling the society on Caste basis like never before. because of his caste based politics, non of the bomb blasts in Hyderabad made any progress. Just because there is no political will behind resolving it. How many innocents my die, YSR wants only votes and power nothing else
3. He allowed to flow the wine in the streets like never before. By this he severly damaged the poor families financial progress so that they will never recover from it. Even the middle class also became poorer. What a development by YSR
4. He sold nearly allmost all the public lands in Hyderabad sorrounding. For the future generations, to start up any govt venture in these areas, there is no govt land.
5. He taken up a lot of irrigation projects, but how many completed?. Its only a gimmick. They created this work only to fill their pockets in the form of commissions.
6. In his rule, corruption has reached to a new level. Non of the Govt of employee fear of being catched in a bribe case. Because they know nothing will happen. Recently they released a G.O. for awarding promotions to these curruptionists.
7. He is giving everything free to every one, which eventually crampts the economic situation of the State Govt. Now every one started to form an association and started to demand exclusive benifits to them. Because of this unplanned spending, if there is any floods etc., Govt will not have anything intheir hands to help the needy.
Towards TDP, i am little bit +Ve and specially i am fan of Chandrababu Naidu, who made Hyderabad a landmark on worldmap and presented himself as a CEO to Govt of AP. Perfectly fine, that the attitude that we want. He is a good administrater.
But during the past 4 Years, he unable to prove himself
as a good Leader from His own parties point of view OR
as a good opposition leader. And
he again again prooving himself that he is not flexible
In Assembly, He should have atleast read the headlines in from the previous Assembly session to the current session. He is failed to present the YSR's dirty politics to the normal man.
Why i said he is inflexible is
1. during his tenure in Govt, he unable to find the problems that Formers facing And he unable to do any damage control ones YSR elivated that issue through "Padayathra". He is just fixing to the opinons what he has. Not every considering others.
2. In Telanga issues also, From day one itself TDP holding on to "United AP". i don't know why... if every one in Telegana wants to get a separate state, give it away. Being a political party in Democratic country, they should reflect the aspirations of people only. He should change his policies atleast now.
Some people may argue, if every one starts asks for their own state, will i accept it. i will not rule out that option also. Its democratic country. They have that freedom to demand.
Forming a separate state is like, dividing family after marriage. similar to Forming a nuclear family. Whether it is good or bad they have to decide. What ever the result, they are the only one, who are going to taste it. Just think, if your father doesn't allowed to form a new family, do you accept it. This is the same issue with Telangana also...
Leaving Telagana issue aside, My conclusion is TDP's leader chandrababu naidu is not flexible and lacks the vision which suits all the sectors of society.
Loksatta's agenda is looks really good . But i am in doubt how they will reach each and every one in the society. I suggest Loksatta to review their purformance in recent elections in Telengana. Loksatta is also a good option to caste the vote.
But last time i saw a TV programe by JP. There he is saying that he restructure the entire Govt organization and dismiss who ever are not working properly. I wonder why he is not building his own party on the same structural lines and show its effectiveness to the people and secondly its not that much easy to fire a Govt employe based on his performance as lot of others things will dragged into the issue at that time.
I would like to see Chiranjeevi's manifest upto the mark of JP's
Even after all these things any one want to vote for YSR or TDP.If yes,just think you may be casting your vote, because you may be one of the few who got benifitted from him or based on the caste. Just think if you are on the otherside, what would be the situation. Think about next generation.Society would be good to you as long as you are on this side. Suppose if you die or you loose your financial situation, you will be thrown to otherside. Then no one can help you.Some of you may say, we are based on caste, and as long as our caste person is in rule, we will be fine. If you think so is every one in your caste getting benifited and suppose tomorrow some other caste person comes into power, they only rise their own community. Its a bad tradition.STOP IT.
If society is good and prejudice, then irrespective of caste and monetary status every get the justice.This is the "SOCIAL JUSTICE" chiru talking about.
Comments are welcomed
Wednesday, August 20, 2008
Netbeans 6.0 - Code generation
The Java editor is capable of generating often used constructs for you automatically. Press Alt+Insert to invoke the code generation menu and pick what you want to generate
To add import statements: Use error hints: Click on the error mark with the light bulb or press Alt+Enter. It will offer you a list of possible classes to import. Pick the proper hint and you are done
Use the import class dialog: Put the caret into the name of an unimported class and press Alt+Shift+I. A list of possible classes to import will appear. Use the smart fix import: Press Ctrl+Shift+I. You will get a dialog that lists all unresolved identifiers in the source. If there is more than one option for resolving the identifier you may choose using the combo box. Classes shown in gray do not fit for some reason.
Method exit points: Putting the caret on the return type of a method definition will highlight all places where the method can exit
Exception throwing points: Putting the caret on an exception in a method declaration throws clause will highlight all the places where that exception can be thrown
If you want to surround a piece of text with a template, just select the text and invoke hints with Alt+Enter
Sometimes it is useful to select text based on Java syntax. To do this, press Alt+Shift+PERIOD (Ctrl-Shift-PERIOD on a Mac) to expand the selection and Alt+Shift+COMMA (Ctrl-Shift-COMMA on a Mac) to shrink the selection based on the structure of your Java source code
How to use Live Templates

Creating a new template You can define new templates: go to Menu->Tools->Options, then choose the Editor category and the Code Templates tab. You may want to look at the existing Java templates and try to create your own
Javadoc popup window Put the caret on a symbol of choice and press Ctrl+Shift+Space. Javadoc view window Go to Window->Javadoc View in the main menu. This will open a separate window which always shows Javadoc for the element under the caret
Opening a type in the editor If you know the name of the type (class, interface, annotation or enum) you want to open, press Alt+Shift+O and type the name into the dialog. Notice that you can use prefix, camel case and wild cards
Implements/Overrides annotation Methods which implement or override another method are marked with a glyph in the editor gutter. Clicking the icon will take you to the overridden method or to the method from the interface. Pressing Ctrl+B does the same.
NetBeans 6.0 - Code Completition
1. Code completion behavior Ctrl+Space lists symbols which are already imported in your source file, plus of course symbols from the java.lang package. Pressing Ctrl+Space again will list all symbols from the project class path whether imported or not. If you want to go to the list of all types immediately you can use the All Symbols Completion, which is invoked by pressing Ctrl+Alt+Space
2. Smart completion - Notice that the standard completion list box is divided into two parts separated by a black line. The first section includes smart completion items. The editor chooses these items based on the current context (i.e. around the current caret position) when completion is invoked. See other bullet points below starting with "smart" for more information and examples of this smart completion feature
3. Completing Keywords You may use code completion for completing keywords: the editor knows which keywords fit into which place in your code.
4. Field/Variable names When you introduce a new field or variable, you often want its name to mimic its type. Code completion now supports this. To prepend a prefix to the guessed name, simply type the prefix and then invoke code completion. This works for method names as well.
5. Smart completion examples
a. After new (with generics) This will help especially when you are declaring a field or variable with complicated generics.
In method call parameters Smart completion will offer only those fields, variables, methods which can be passed as an argument to the method
For exceptions In a catch block smart completion will offer only those exceptions which have been thrown in the try block but not yet caught
Parameter guessing Code completion of method calls guesses which variable, field or parameter should be used based on type and similarity of the name
Code completion ending character Notice that you may select the item of choice with different keys. Selecting with Enter you'll get what you expect. Should you select the item with ".", "," or ";" code completion will append the character you typed at the end of the completed word
Creation of elements - Invoking code completion between class members will offer to create a constructor (either a default constructor or one initializing uninitialized fields), override methods or implementation methods
Tuesday, August 19, 2008
Netbeans 6.0 Shortcuts / Tips
1. If the code you pasted in is not formatted correctly, press Alt-Shift-F to reformat the entire file
2. Press Ctrl-Space to open the code completion box. A short list of possible ways to complete the word appears
3. Type sout and press Tab. The sout abbreviation expands to System.out.println(""); with the cursor positioned between the quotation marks.
4. Type psfs and press Tab. The psfs abbreviation expands to private static final String.
5. To supply command line arguments to the program Right-click the project node, choose Properties, and select the Run node in the dialog's left pane and then enter the arguments at the arguments dialog box
6. To run the project choose Run à Run Main Project (F6) from the Run menu
7. If you build a project and then later change classes, it is good to remove all build artifacts from your system and create a fresh build of the application. You can do this with the Clean and Build command (Shift-F11)
8. To create JUnit Test cases select the java file in the Project folder and (Ctrl-Shift-U)
9. To run the JUnit Test cases , select the project node in the project folder and Alt-F6
10. press Ctrl-F8 to set a breakpoint
11. To Debug Main Project Ctrl-F5
12. Click Step Into (F7) in the toolbar to step through the program
13. Generally speaking, Code Completion is useful for filling in missing code, such as symbols and keywords, automatically. As of NetBeans IDE 6.0 you can now also use Code Completion to generate whole methods. This is useful if you want, for example, to generate a constructor, override methods, or implement methods.
14. Generating Code Using the Code Generation Dialogs: Alt-Insert. Using it we can generate getters, setters, hastcode() and equal() methods
15. The IDE's Java editor provides several ways to add import statements for one or more classes, each offering you a list of possible classes to import when you click on the light bulb error mark or press the appropriate key combinations. In addition, the Editor also displays error hints that assist you with removing imports that aren't needed in your source.
16. Place the cursor on the line of the class that wasn't imported and press Alt+Enter. Alternately, you can click the warning mark in the Annotation Stripe (along Editor's left edge)
17. The IDE's Java editor also provides several other methods for managing imports, such as pressing Ctrl-Shift-I to import multiple types at once and pressing Alt-Shift-I while the cursor is positioned in a type identifier, which enables you to import that specific type
18. To duplicate/move the current line or multiple selected lines: Position the cursor on the line or selection you want to duplicate/move. Press and hold Ctrl-Shift / Alt-Shift, then press either the Up or Down cursor key to copy and paste the code above or below the original line.
19. To instantly Rename all the occurrence of a field, method, variable etc., place the cursor on the filed and press Ctrl+R and then enter the new name. To exit from it press Enter / Esc
20. To see the javadoc for an element press Ctrl+Shift+Space