Developer notes

• 23Apr

  Business Objects Data Integrator (BODI)

  buhobuscador BODI, Code, Tools No Comments

  This is a tool to do data extraction. The term is well known as ETL, Extraction, Transform and Load.

  I would say that is very easy to use; its proprietary script language is very basic and since it is mostly 5GL a lot of “coding” is just assembling (drag&drop and connecting)  some predefined objects.

  I also had some experience with SAS ETL tool and I have to say that both of them are very similar. Sadly my interaction with SAS tool was very limited and I cannot do a fully comparison against BO tool.

  Although I am an “open source” guy I still have to do my job with whatever tools my employer has. So when it was decided that we were going to use BODI, I accepted the challenge and started reading some documentation and doing some prototypes. Everything seemed to be fairly easy…

  After some weeks some questions started to come… how do we implement this complex logic? how do we deal with transactions? Where do we use scripting against 5GL coding?

  So we finally found some caveats using this tool:

  • No complex logic! If your process has to do validations then do all (or most part) of them before trying to do any extraction.
  • Transactions! I understand the whole flow (job in terms of ETL) should be done in a single transaction, but if you do some scripting then forget about it; every SQL statement that you send thru it  will be committed and not roll-backed if something goes wrong (you have a Catch object though).
  • Predefined objects! Being a 5GL tool it has some objects that will do some tasks for you and this looks great until… you get to know that in most of the cases you have to give the big work load to DB. Yes I know that’s why DB exist but I expected that components of this tool do that for me (in an efficient way). I mean if I have two or more tables with millions of records and I want to do a join I expected that an optimized query were built and executed by the tool (based on the table objects and columns to do joins) ; instead as result I got this tool trying to load millions and millions of records doing a join in memory… “all that glitters is not gold”.

  In defense of BODI I have to say that probably I broke all the  established best practices but in my favor I have to say that there is an incredible lack of documentation; so if you are looking for some help you can read/post in this forum.

  The advantages:

  • Rapid development. If you need to do a bulk of data thru different types of relational DB’s (or file to file, relational to file and vice-versa) then this is a good solution.
  • Batch processes. If you have to do data extraction continuously; it has a simple but good interface that will allow you to setup your job to run N times per day (hour, week, etc).

  Doing some googling I found a site with open source ETL projects; I have not tried them yet but maybe I will give it a try to some of them at home just for fun…

  Ok – Even if it is a very basic info I hope this help you to know the to-do/not-to-do with BODI. Also you will find the forum very helpful, it is frustrating to do research for hours (days) without finding anything; so the forum is an oasis in the middle of the desert.

  Cheers,

  Buho

  Tags: ETL

• 11Apr

  Effective Java (notes) – Creating and destroying objects

  Moctezuma Code, Java No Comments

  Item 1. Consider static factory methods instead of constructors.

  Advantages:

  1. One advantage of static factory methods is that, unlike constructors, they have names.
  2. They are not required to create new objects each time they are invoked. This allows immutable classes to use preconstructed instances, or to cache instances as they are constructed.
     Help to increase performance.
  3. Another advantage is that, unlike constructors, they can return an object of any subtype of their return type. This gives you flexibility in choosing the class of the returned object.
  4. They reduce the verbosity of creating parameterized type instances.

  Disadvantages:

  1. The main disadvantage of providing only static factory methods is that classes without public or protected constructors cannot be subclassed.
  2. They are not readily distinguishable from other static methods. Also they do not stand out in the API documentation as constructors do.

  Item 2. Consider a builder when faced with many constructor parameters.

  Static factories and constructors share a limitation: they do not scale well to large numbers of optional parameters.

  Alternative one:

  Traditionally, programmers have used the telescoping constructor pattern, in which you provide a constructor with only the required parameters, another with a single optional parameter, another with two optional parameters and so on, culminating in a constructor with all the optional parameters.
  The telescoping constructor pattern works, but it is hard to write client code when they are many parameters, and harder still to read it.

  Alternative two:

  JavaBeans pattern, in which you call a parameterless constructor to create the object and then call setter methods to set each required parameter and each optional parameter of interest.
  This pattern has none of the disadvantages of the telescoping constructor pattern. Unfortunately, the JavaBeans patter has serious disadvantages of its own. Because construction is split across multiple class, a JavaBean may be in an inconsistent state partway through its construction.

  Third alternative (the good one):

  Using the Builder pattern which combines the Telescoping pattern and the JavaBeans pattern. Instead of making the desired object directly, the client calls a constructor (or static factory) with all of the required parameters and gets a builder object. Then the client calls setter-like methods on the builder object to set each optional parameter of interest. Finally, the client calls a parameterless build method to generate the object, which is immutable. The builder is a static member class of the class it builds.
  The Builder pattern is more verbose than the telescoping constructor pattern, so it should be used only if there are enough parameters, say four or more (but you may want to add parameters in the future).
  In summary: The builder pattern is a good choice when designing classes whose constructors or static factories would have more than a handful of parameters.

  From Effective Java: http://java.sun.com/docs/books/effective/

  Tags: Code, Java

• 14Aug

  Online storage applications

  rayiceman Tools No Comments

  Besides Google Docs, I have been using Dropbox and Box.Net the last months. Both are online storage and sharing applications and have similarities. Let’s talk about them and how I personally use them.

  ——————————————————————–

  

  
  It syncs your files online and across your computers and has a cross-platform client (Windows, Mac, and Linux).

  Operation
  You have to install the Dropbox client. When installing you will need to define a Dropbox folder. Once installed, any file you drop into your Dropbox folder will synchronize and be available on any other computer you’ve installed Dropbox on, as well as from the web. Also, any changes you make to files in your Dropbox will sync to your other computers, instantly. Work on files in your Dropbox even if you’re offline. Your changes sync once your computer has an Internet connection again.
  For sharing with other users, put the folders you want to share in your Dropbox folder and invite people to them. Another option is to place your files in “Public” folder that lets you link directly to files in your Dropbox. You can also send people links to specific files within your Dropbox.

  Advantages

  • File Sync and sharing
  • Online Backup (Undo/Undelete/Restore)
  • History (30 days of undo history, with unlimited undo available as a paid option)
  • Web Access. From any computer or mobile device.
  • Security and privacity. Shared folders are viewable only by people you invite. SSL for transmission, file encryption (AES-256). Dropbox employees are not able to view any user’s files.

  Storage space
  2GB of online storage for free, with up to 100GB available to paying customers.

  ——————————————————————–

  
  
  It is a web-based service for content management, file sharing and collaboration. Not client needed so perfect for multi-platform environments.

  Operation
  Go to Box.Net page and set up your account. After this, behavior is very similar to Google Docs. Create new web documents and organize them in folders. Upload files from your computer. Share your files with other users or all the world.

  Advantages

  • File sharing, online workspaces
  • Online Backup and history
  • Web Access. From any computer or mobile device.
  • Security. Data transmission is encrypted with 256-bit SSL
  • Customizable. Add extra services or widgets.
  • File commenting and group discussion

  Storage space
  1 GB of online storage for free, 5, 10 or more GB available to paying customers.

  ——————————————————————–

  Applications

  • Replace emailing file attachments to yourself and other people
  • Stop using USB drives to move files between computers
  • Rename files to keep a history of previous versions
  • Forget complicated backup software
  • Use instead of FTP servers or another system-specific sharing methods.
  • Team work, team projects, collaboration

  Then, what are some of their main differences?
  With Box.Net you don’t need a client but you always need an Internet connection. On the other hand, Dropbox needs a client, but this enables you to work offline and this is a very useful advantage.
  Box.Net has a lot of extra services and widgets that Dropbox hasn’t. That’s is because, I believe, Box.Net is very focus on collaborative work.

  Because of that I uses Dropbox to keep synchronized my personal files between all my computers. With Box.Net and using an extra widget I share documents and files to my blog’s readers.

  Here is a comparison between these two tools and others
  http://en.wikipedia.org/wiki/File_hosting_service#Comparison_of_notable_file_hosting_services

  Have you tried these or any other online storage applications?
  What is your favorite one?

  Tags: box.net, dropbox, google docs, sharing files online, storage online

• 14Aug

  Short Weblogic Portal Intro

  rayiceman Code, Java, Tecnologies, Tools No Comments

  Technically, a portal is a container of resources and functionality that can be made available to end users through views. These portal are called desktops in WebLogic Portal.

  Benefits to the users:

  • Aggregation – From a simple page user can gradually get a page with multiple content and applications.
  • Customization – The user determines how the portal looks and feels.
  • Personalization – Specific content  according to the user’s interests and needs.
  • Organization – The user can arrange the content and applications to make better sense of the information.
  • Integration – The user can work with multiple applications and content sources in a unified fashion.

  Portals typical functionality:

  • Search – Enterprise and web-based search facilities
  • Content Management – Creation, management, and delivery of content
  • Content Repurposing – Including content from multiple disparate data sources

  Frequently, portals also include the following features and benefits:

  • Workflow – Business process management
  • Single Sign-On – Allows users to log on once for all applications within the portal

  For Weblogic Portal, you usually create the parts of a portal using Workshop (WebLogic IDE) and then you assemble it into a desktop using the WebLogic Portal Administration Console (WPAC). When you create a new portal using the WPAC, you are really creating an empty portal to hold different versions of the portal (desktops) that can be targeted to specific users.

  It is the desktops to which you add the portal resources and navigation such as books, pages, and portlets that make a dynamic portal.

  The next step is to complete the following tutorial:

  http://download.oracle.com/docs/cd/E13155_01/wlp/docs103/tutorials/index.html

  Tags: Portal, Weblogic Portal

• 27May

  Java Code Coverage for Eclipse

  Moctezuma Code, Java, Tips, Tools No Comments

  Today I started using EclEmma which is a free Java code coverage tool for Eclipse IDE.

  Basically it helps to identify the areas in your code that are (and are not) covered by a test case. This will help to improve the way you code and create JUnits.  You may become the one in your team with a 100% code coverage  :)

  

  More info here.

  Tags: Code, Herramientas, open source

« Previous Entries