Posted on

Object-relation mapping without the container

http://www-128.ibm.com/developerworks/java/library/j-hibern/?ca=drs-

Right now, anything that detours EJB 2 in favour of another persistance mechanism is my friend. (ie EJB3 ;-), hibernate).

The linked IBM developerworks article focuses on Hibernate and this thing I didn’t know existed until a few days ago, Spring.

On another anti-EJB note, I was reading Beyond Java by Bruce Tate. From section 1.3

Keep in mind that I’m a cynic at heart. When it comes to technologies, it takes a whole lot of effort to get me excited. I still have never written a web service, at least with the massive IBM and Microsoft stacks, and I didn’t write my first EJB until 2003. I’ve never written an EJB entity bean unless it was to build a case against them, and never will. I’ve instead preferred simpler architectures, like REST, POJO programming, transparent persistence, and Spring. Even then, I was late to those parties.

Ah. Validation from a respected industry individual.

Posted on

J2EE for you at home

A plethora of links (mainly tutorials) to get you through the path of J2EE learning. Personally I’d like to shoot EJB’s out of a cannon due to the troubles they have given, however with a little time and patience, (or the willingness to look at other persistance tech such as Hibernate), you too can be a J2EE master.

The Sun Java J2EE Tutorial (version 5)

I learnt using the previous Pointbase one, but this is just as good, if not better.  Very accessible and lots of samples/tutorials.

Eclipse Web Development Tools

Eclipse has a plugin to help develop beans out of the box. It offers things like jsp highlighting, deployment and integration with Tomcat, JBoss and others.

The community section offered some useful tutorials to make the most out of this environment, which looks promising for new and old J2EE developers alike.

O’Reilly Books
Enterprise Javabeans
JavaServer Pages

O’Reilly’s Java Developers Page
Lots of great articles and links to Java and J2EE info.

A great article on EJB3 found through the former link: Standardizing Java Persistence with the EJB3 Java Persistence API, talks about persistence and coming from EJB2.

Posted on

Jude smells better than a Rose

http://jude.change-vision.com/jude-web/product/community.html

The guys at work started using a modelling tool known as Jude to help with their design of various projects and enhancements. Jude comes in a community (free) and professional version and the free version allows you to create the following UML diagrams:

  • Class (Object/Package/Robustness)
  • UseCase
  • Sequence
  • Collaboration
  • Statechart
  • Activity
  • Component
  • Deployment

It also has some Java code generation and importing although it didn’t seem to handle generics at all (claimed a syntax error) so I’m not sure about Java 5 support.

The application appears much more robust than Rational Rose ever did. I wish I knew about it for my System Design and Implementation subject this semester as one of our group members couldn’t get Rose to run on their home PC. The price of Jude community is more student friendly also ;-), as well as benefiting from the platform independence that Java provides.

Posted on

A goody in SDK clothing

http://jgoodies.com/freeware/jdiskreport/index.html

JDiskReport is a system filespace analyser, that is part of a demo of the jgoodies.com system.

For functionality and ease of use it scores highly with a strong comparison to SpaceMonger without the treemaps. I like its multiplatformness, abiltity to exclude directories (useful for symlinks) and its freeness.

Posted on

Ajax: A New Approach to Web Applications

http://adaptivepath.com/publications/essays/archives/000385.php

Well, those in development circles will by now at least have heard of this new fanbangled architecture for building rich web client apps known as Ajax. This article is a very small skim of the froth of what AJAX is about but I liked the pictures 🙂

Posted on

CVSNT server

http://web.telia.com/~u86216121/ViewCvsSetup.html

I have had a CVSNT running on my desktop for some time now. Recently with more group assignments occuring at Uni, I decided to open this up to the rest of the world (well just the 3 other people that I’m participating in an assignment with)

Considerations for whether it is worth running a CVS server included the fact that the Uni firewall may infact block the relevant ports, so I looked at a way to publish the CVS project contents to the web.

The ViewCVS package contains a mini-webserver and allows users to browse a repository and download its files via FTP. To install and get this to work on a windows box with IIS can be a bit fidly but a Bo Berglund wrote an installer and has placed instructions here on how to set this up.

Bo also has another CVSNT getting started page which has links to a variety of CVS related info (books, tutorials and other software). Great if you are just starting out in CVS. I’ve came across those links before and was going to publish them seperately until I realised that Bo had bet me to it.

Edit: Some links just so you can concentrate your reading.

Posted on

C++ Compilation and Linking

Taken from Monash CSSE’s 3400 Application Development with C++ webpage:

Firstly, with the normal compile and link process:
We write our programs in a file in a source language that the compiler understands (can parse). If we write code the compiler does not understand it tells us with compile error messages. If we write code that it can understand but that could have problems we get warning messages.

After the compiler has understood our code it generates machine instructions that, when executed, will do what the compiler understands we wanted the computer to do. The instructions could be native machine code or assembler (in which case the assembler is then translated (assembled) to machine code), even another programming language. The machine code often has references to data or functions in other files, such as other parts of our program or the standard libraries.

The result of compiling our source code file is an “object” file.

As already mentioned, the object files refer to other object files or libraries. Also, the various object
files and library functions must be organised into one file that the operating system can load into memory and execute. So the various object files are loaded into memory and all of the references mentioned earlier must be “fixed up” so that the actual address of the referenced data or function is used in the machine instructions. The libraries are also searched for the functions our code calls, and those functions are also loaded into the new program. Not surprisingly this process is called “linking”, and the program that does it is called the “link editor”.

If the link editor finds references but cannot find what they refer to, it reports these as errors.

The result of linking is an executable file.

OK, so where do C++ templates fit in?

When the compiler encounters a template declaration (it should be all together in a header file), it just parses it to ensure it is correct, and stores it until our code makes use of it. When we declare or define a class that uses (instantiates) it, the compiler generates the new class. This could lead to new compile errors. Then the linker will try to link our program and it may find errors too.