14 December 2011

Geek & Poke

Great geek cartoons ...


Jobat is the winner in the job site category in the Site of the year 2011 election. In the open competition they make the top ten. Great job by the Uniway team there!

29 November 2011

Calendra lives on as Cognitum

Calendra Directory manager was a pretty good platform for rapidly developing web applications based on directories, databases, provisioning and workflow. As such it was a great tool for building Identity a Access management related applications.
Calendra was acquired by BMC Software, but never found its place in the portfolio of the company, and development slowed down.
This year ownership of Calendra was transferred to ITConcepts. Cognitum is the new name for the product. This month a new version of the product, Cognitum 7.7 is released. In addition to some bug fixes it aligns Cognitum with current standards: Java 6, JDBC 4, Tomcat 7 and Windows 7.
The roadmap for the product again looks ambitious now. The next version of the product is expected to merge some Calendra 4 features back into the main branch (Basket functionality, Studio Wizards, History actions...).
here's an overview of Cognitum's architecture:



18 November 2011

Devoxx redux

Stephan Janssens: There will be a Devoxx France event in Paris, 18-20/4. 75% french / 25% english.

Mark Reinhold: Oracle thinks a two year release cycle is optimal. So we can expect Java 8 mid 2013.
   Let me think: that puts java 9 mid 2015

Mark Reinhold: We're planning reified generics and unified primitives for Java 9.

Mark Reinhold: Swing is a Sun development. Oracle will concentrate on JavaFX. Do not expect many new initiatives from Oracle for Swing.
  Well, I can name some other Sun developments

@Jax-RS 2 talk: JAX-RS will be in the Java EE7 web profile. 

Matt Railble: great video in presentation on Play, HTML5, Jade and CoffeeScript.

Shaun Smith: For JPA 2.1 EclipseLink is doing work on

  • multitenancy: separte datasets per group of users
  • domain model extensions: storing generic attributes (name/value pairs)
Joshua Bloch: I believe in evolution, even if my country does not.


Joshua Bloch: Who cares about the Java VM, it's the languages that count.

Greg Luck: JSR347 (Datagrid) will be based on JSR107 (caching)


Greg Luck: We talked with oracle to Apache license the TCK (Technology Compatibility Kit). Oracle legal wants to avoid implementations claiming 70% compatible and people testing compatibility of someone else's implementation. We are working with Oracle on a new license for the TCK.

16 November 2011

Create a test case in Intellij IDEA

Position yourself on the name of the class you want to create a test for and press [ALT] + [ENTER].











 

IntelliJ will let you select your test framework (JUnit 3/4, TestNG) and you can select all methods in the original class you want to generate skeletons for (pity they forgot a select all button).






12 November 2011

EDF convicted for hacking greenpeace


Electricité de France is the second player on the Belgian energy market, selling under the Luminus brand name.
Looking at  Electricit√© de France's website shows you a green company. They claim to have a carbon emission that's three times lower than their average competitor. This is not surprising: EDF is the world's biggest producer of nuclear energy.

Flamanville 3 nuclear reactor (under construction)
In 2006 EDF, which is controlled by the French state,  hired private investigators Kargus Consultants. They wanted to anticipate Greenpeace actions in the 2006 debate on building a new nuclear reactor in Flamanville near the channel.  Kargus hacked greenpeace computers and stole confidential documents. Kargus got caught however and were charged in court. The court found ound EDF guilty of "complicity in computer piracy". Former policeman Pierre-Paul Francois and former rear admiral Pascal Durieux, who were both in charge of EDF's security, were sentenced. The head of Kargus, a former french secret agent, and Alain Quiros, Kargus' information specialist, were sentenced as well.
Alain Quiros was sentenced as well for a separate case of hacking a french anti doping agency for Floyd Landis. After winning the Tour de France in 2006, he was stripped from his victory when it was discovered he had been using doping in the 17th stage which he won after an epic solo escape.

9 November 2011

SABAM wants 3% of ISP subscriptions

After getting money out of children creches, computer hard disk, taxi's, company phone waiting tunes and the like, Belgium's author rights association SABAM is now attacking ISP's. They want their fair share of the pie, and ask for 3.4% of your ISP subscription, because it provides access to coyprighted work.
SABAM says this does not mean that the sites that distribute coyrighted material (e.g. YouTube) do not have to pay for the copyright anymore (double pay!).
SABAM does not want to be seen as the bad guy, and expresses the hope ISP's will not charge end users for the money they ask.

28 October 2011

Patent war II

Earlier we reported on different types of patent law suits between Microsoft and Motorola.
Here's a global overview of lawsuits in the mobile world from Design Language News, a fine site specializing in visualizing data.



25 October 2011

Light field camera

The eye and conventional camera's capture the colour and intensity of light. They need to focus to get a sharp image for a certain distance.

Light field camera's also capture the direction of the light rays.
This allows you to reprocess and refocus the light information afterwards.
Storing this extra information takes up about 200 times the space of a classical picture. So the camera's have to sacrifice resolution to keep picture storage size within limits.
Lytro will bring a consumer light field camera to the market next year.  An 8GB version costs $400 and stores 350 pictures.

You can refocus some pictures in a demo at their site.

2 October 2011

EDAM: Easy Development And Maintenance

Design patterns make code more flexible and easier to evolve and test.
Design patterns make code more complex and harder to write.
Strike the right balance between easy work now (development) and later (maintenance).

25 September 2011

JPA labs – high level instructions (edit)

Lab 3 Exercise 2 Task 1

Adjusting the table and column names

  1. Create the com.acme.entities.AuctionUser entitiy
    1. Follow the same procedure as in Lab 1 Exercise 3 Task 3, steps 1-6
    2. Add the attributes shown in the Student Guide page 2-9, Figure 2-4
    3. Press ALT+INSERT to  add a default constructor and a constructor accepting all attributes except the auctionUserId
  2. Add an annotation to save the entity to the table A_USER
  3. Add an annotation to save the auctionUserId attribute to the id column
  4. Add an annotation to save the displayName attribute to the name column.
    1. Set the column length to 50.
  5. Modify the main method created in Lab 1 to save an AuctionUser entity
    1. At the beginning of the method create auctionUser JaneDoe with email address jane@doe.com
    2. After the statement to persist the item, add a similar statement to persist the user
  6. Choose Run -> Run Main Project
  7. Follow the same procedure as in Lab 1 Exercise 3 Task 3, step 9 to run the project and verify the table was created as intended and JaneDoe was inserted.

Lab 4 Exercise 2 Task 2

Working with the entity manager

  1. In the Item entitiy
    1. Press ALT+INSERT to generate a constructor that takes all attributes except the id as an argument
    2. Press ALT+INSERT to generate a default constructor
  2. Create the ItemDao class in the (new) com.acme.daos package
    1. Add a static EntityManagerFactory attribute
      1. Initialize the attribute with an EntityManagerFactory for your persistence unit
    2. Implement the method
      private EntityManager getEntityManager()
      The method should return an EntityManager created from the EntityManagerFactory attribute
    3. Implement the method
      public Item save(Item item) 
      1. The method should call the getEntityManager method
      2. The method should persist the item within a transaction
        1. Look at the main method for inspiration
      3. return the item
  3. Create a unit test to test the save() method.
    1. Right-click the Project node and choose New –> Other.
    2. Select JUnit from the list of Categories and JUnit Test from the list of File Types, then click Next
      1. Type ItemTest for the class name
      2. Select Test Packages as the location
      3. Type com.acme.daos for the package name
      4. Click Finish. 
      5. Select JUnit 4.x if prompted for the JUnit version:
      6. Add an import for static assertXXX JUnit utility methods:
        import static org.junit.Assert.*;
      7. Add a static ItemDao attribute. Initialise it in the @BeforeClass annotated method.
      8. Create a test method called save() to test the save() method on the ItemDao
        1. Annotate the method with @Test
      9. In the test method
        1. Create a new Item and set all attributes except the id
        2. Save the Item using the ItemDao
        3. Use the assertFalse method to test the Item id is not null
        4. assertFalse("id should not be null", item.getId()==null);
        5. Right click ItemTest.java and choose Run File
        6. If you see a green bar with 100% in it, the test passed. If you see a red bar, the test failed.
      10. In the ItemDao class, implement the following method:
        public Item findByPrimaryKey(Long id)
      11. Create an annotated test method called find  in the ItemTest class to test the findByPrimaryKey method. In this method:
        1. Create a new Item and set all attributes except the id
        2. Save the Item using the ItemDao
        3. Pass the primary key of the saved item to findByPrimaryKey to retrieve the Item from the database
        4. Use the assertEquals method to test that the key of the returned Item has the same key.
        5. Run the test and correct errors until it succeeds.
          Optional steps
        1. Create a method in the ItemDao class.
          public void deleteByPrimaryKey(Long id) 
          1. Get an entity manager
          2. Start a transaction
          3. Look up the Item using the getReference method on the entity manager
          4. Delete the item using the remove method on the entity manager
          5. Commit the transaction
        2. Create an annotated test method called find in the ItemTest class to test the deleteByPrimaryKey method. in this method:
          1. Create a new Item and set all attributes except the id
          2. Save the Item using the ItemDao
          3. Pass the primary key of the saved item to deleteByPrimaryKey to delete the Item from the database
          4. Pass the primary key of the saved item to findByPrimaryKey to retrieve the Item from the database
          5. Use the AssertNull method to verify that the item is not found.

        Lab 5 Exercise 2 Task 1

        Creating a unidirectional One-to-One relationship between two entities

        1. Create the com.acme.entities.Auction entitiy with these attributes:
          private Long auctionId;
          private BigDecimal startAmount;
          private BigDecimal increment;
          private String status;
          private Date openTime;
          private Date closeTime;
          private Item item;
          
        2. Map the Date attributes to TIMESTAMP columns using the @Temporal annotation
        3. Establish a OneToOne relation with Item
        4. Press ALT+INSERT to generate getters and setters, a default constructor and a constructor accepting all attributes except the auctionId
        5. Create the com.acme.daos.AuctionDao class
          1. Copy the static EntityManagerFactory attribute from ItemDao
          2. implement the same methods as in ItemDao, but this time for the Auction entity
        6. Create a unit test to test the save() method.
          1. Right-click the Project node and choose New –> Other.
          2. Select JUnit from the list of Categories and JUnit Test from the list of File Types, then click Next
          3. Type AuctionTest for the class name
          4. Select Test Packages as the location
          5. Type com.acme.daos for the package name
          6. Click Finish. 
        7. Add an import for static assertXXX JUnit utility methods:
          import static org.junit.Assert.*;
        8.  Add an attribute
          static AuctionDao auctionDao;
        9. Initialise it in the @BeforeClass annotated method.
      12. Create a test method called save() to test the save() method on the ItemDao
        1. you may modify the method to pass the attributes in the constructor instead of using the setters
            @Test
            public void save(){
                Auction auction = new Auction();
                auction.setOpenTime(new Date());
                GregorianCalendar cal = new GregorianCalendar();
                cal.roll(Calendar.MONTH, true);
                auction.setCloseTime(cal.getTime());
                auction.setStartAmount(new BigDecimal("100.00"));
                auction.setIncrement(new BigDecimal("10.00"));
                auction.setStatus(Status.OPEN)
                auction = auctionDao.save(auction);
                assertTrue("id is greater than zero", auction.getAuctionId() > 0);
            }
        
      13. Right click ItemTest.java and choose Run File. Run the test and correct errors until it succeeds.

      Lab 5 Exercise 3 Task 1

      Creating a bidirectional One-to-Many/Many-to-One relationship

      1. Add a bidirectional One-to-Many/Many-to-One relationship between Auction (1) and Bid (many)
        1. Add an annotated bids attribute to the Auction entity
          1. Set cascade mode to ALL
          2. Initialize the attribute to an empty list of bids
          3. Add an auction attribute to the Bid entity
            1. Press ALT+INSERT to generate auction getter/setter methods
            2. Add an annotation for the relationship
            3. Press ALT+INSERT to generate a constructor that takes all attributes except the id as arguments
            4. Press ALT+INSERT to generate a default constructor
            5. Implement these methods in the Auction entity
              public void addBid(Bid bid)
              public int getBidCount()
          4. Implement a saveBids() methods in the AuctionTest class
            1. Create an auction
            2. Add 3 new bids with amounts of 150, 175 and 225
            3. Save the auction
            4. Assert that the saved auction got an ID
            5. Assert that the new auction has 3 bids
            6. Run the test until it passes.

          Lab 6 Exercise 2 Task 1

          Persisting an Entity with a superclass

          1. Create an entity called com.acme.entities BookItem.
          2. Make the BookItem entity a subclass of Item.
          3. The attributes of the entity are described in module 2 of the Student Guide.
          4. In the main method add the creation of a BookItem and save it to the database.
          5. Run the main method
          6. Examine which changes were made to the database tables

          Lab 7 Exercise 2 Task 1

          Persisting an Entity with an enum Field

          1. Create the Status enum.
            1. Right click on the com.acme.entities package and choose New>Java class
              1. Type Status for the Class Name.
              2. Choose enum for the type
            2. Click OK
          2. Add these values to the enum: OPEN, CLOSED, CANCELLED
          3. Refactor the type of Auction.status and change it to Status
            1. Change getter and setter methods
            2. Change the call to setStatus in AuctionTest.java
          4. Run the AuctionTest and correct errors until it succeeds
          5. Check the database definition of Auction.status and check the inserted data. What has changed?
          6. Add an Enumerated annotation to the status field and set enumeration type to STRING
          7. Run the AuctionTest and correct errors until it succeeds
          8. Check the database definition of Auction.status and check the inserted data. What has changed?

          Lab 7 Exercise 3 Task 1

          Persisting an Entity with a List field

          1. Add a Set of String keywords to the Item entity and initialize it to an empty Set.
          2. Annotate it as an ElementCollection
          3. Implement these methods:
            public void addKeyword(String keyword)
            public List<String> getKeywords()
          4. Add an annotated test method saveKeywords() to ItemTest. You can use the test methods for bids in Auction as a source of inspiration.
          5. Run the AuctionTest and correct errors until it succeeds.
          6. Describe the database table where the keywords are saved.

          Lab 8 Exercise 2

          Performing a query with the Java Persistence API QL

          1. Add a dynamicJpqlQuery() test to the ItemTest class. In the method
            1. Perform this JPQL query (within a transaction)
            2. DELETE FROM Item i
              1. What does this query do?
            3. Create 3 Items using ItemDao.save(Item i), using different values for all atributes.
            4. Save them to the database
            5. Perform a JPQL query to retrieve  them
            6. Assert you retrieved 3 results
            7. perform a  JPQL query to retrieve only items in stock
            8. Assert you retrieved the correct number of results
          2. Optional: Add a testPaging() test method that creates 25 Items and retrieves them in groups of maximum 10. Verify that it runs correctly.

          Lab 8 Exercise 3

          Performing a query with SQL

          1. Copy the dynamicJpqlQuery() test in the ItemTest class to nativeSqlQuery()
          2. In the method replace all queries with native queries

          Lab 8 Exercise 4

          1. Add a constructor to the Item class that accepts all attributes
            1. Type ALT+INSERT into the item class
            2. Choose Constructor…
            3. Check all attributes except the ID
            4. Click Generate
          2. Add a default constructor to the Item class
            1. Type ALT+INSERT into the item class
            2. Choose Constructor…
            3. Click Generate
          3. Copy the CriteriaTest.java file from the labs08 directory to the com.acme.entities package in the test directory
          4. Examine the code
          5. Run the code

          Lab 9 Exercise 2 Task 1

          Creating and running a named query

          1. Define a named query called ClearAuctions using an annotiation on the Auction entity that deletes all auctions
          2. Define a named query called FindByStatusAuctions using an annotiation on the Auction entity. To define multiple named queries use @NamedQueries:
            @NamedQueries( {
                @NamedQuery(name="xxx",query="XXXX"), 
                @NamedQuery(name="yyy",query="YYY") }
            1. The query should select all auctions with a certain status
            2. Set the status in the query as a named parameter
          3. Add an annotated test method called testNamedQuery() to the AuctionTest clas.
          4. Execute the ClearAuctions query (you can find inspiration in the tests in the previous chapter)
            • Do not use the Dao, but create an EntityManager
            • Perform the delete operation within a transaction
          5. Execute the FindByStatusAuctions query to look for all closed auctions
          6. Assert no entries are found
          7. Run the test and correct errors until it succeeds
          8. Modify the testNamedQuery() test to insert three auctions and add them to the auction table
            1. Add a convenience constructor with common attributes and a default constructor to the entity
            2. The start date of the first auction should be between those of the second and the third item(we will use this in the next exercise)
            3. Only two auctions should be in open
            4. Save them using the Dao
          9. Assert one entry is found
          10. Run the test and correct errors until it succeeds

          Lab 9 Exercise 2 Task 2

          Creating multiple named queries

          1. Write a new NamedQuery FindAllAuctions that finds all auctions.
          2. Copy the testNamedQuery() test to a new test and call it testOrderedQuery()
          3. Replace the last query in the copied test method (FindByStatusAuctions) with the FindAllAuctions Query and store the results in a List
          4. Assert that the first auction starts after the second.
          5. Run the test and correct errors until it succeeds
          6. Write a new NamedQuery called FindAllOrderByOpenTimeAuctions that sorts by ascending openTime.
          7. Add the query at the end of testOrderedQuery.
          8. Assert that the first auction starts before the second.

          Lab 10 Exercise 2

          Performing a Query With Multiple Criteria

          1. Define a named query called clearItems that deletes all items. Use an annotation on the Item entity
          2. Add an annotated test method called incompleteItems() to the ItemTest class.
          3. In the incompleteItems method
            1. Call the clearItems named query
            2. Create 3 items.
              1. An Item with a description
              2. An Item with an image
              3. An Item with an image and a description
                   (Use test methods from previous labs for inspiration)
          4. Build a criteria query that selects all items that have a description OR an image that is NULL
            Hint: use CriteriaBuilder.isNull()
          5. Execute the query
          6. Assert 2 entries are found
          7. Run the test and correct errors until it succeeds

          Lab 10 Exercise 3 (extra)

          Performing a query with a named parameter

          1. Copy the incompleteItems() test method and call the copy namedParameter()
          2. Replace the query with a Criteria query that selects all items with a given description
            1. The description should be received as a parameter called “desc”
          3. Execute the query for each description in your items
          4. Assert that you get exactly one result each time
          5. Run the test and correct errors until it succeeds

          Lab 13 Exercise 2 Task 1

          Creating a Composite Key

          1. Create the BookPk class in the com.acme.enitities package
          2. Add the @Embeddable annotation and the Serializable interface to theclass declaration.
            @Embeddable
            public class BookPk implements Serializable{
          3. Add the following fields:
            private String title;
            private int edition;
            1. Right-click an empty line and choose Insert Code.
            2. Choose Getter and Setter.
            3. Select all fields and click Generate.
            4. Right-click an empty line and choose equals() and hashCode().
            5. Select all fields in the list.
            6. Click Generate.
          4. Create the TextBook entity class in the the com.acme.enitities package
            1. Add an EmbeddedId of type BookPk
            2. Add attributes
              private List<String> authors;
              private int yearPublished;
            3. Extra: Annotate the authors attribute as an ElementCollection
          5. In the main method add the creation of a BookItem and save it to the database
          6. Run the main method
          7. Examine which changes were made to the database tables 

          Lab 13 Extra: Exercise 3 Task 1

          Using validation

          This lab supposes the validator reference implementation has been downloaded to $Home/pkg

          1. In the projects window right click the libraries folder and select Add Library
            1. Click Create...
            2. Enter Library Name: Validation
            3.  Click OK
              1. Click Add JAR/Folder...
                1.  Select $HOME/pkg/hibernate-validator/hibernate-validator*.jar
                  1. * depends on the version of validator
              2. Click Add JAR/Folder...
                1.  Select $HOME/pkg/hibernate-validator/lib/required/validator-api-1.0.0.GA.jar
              3. Click OK
            4. Click Add Library
          2. In the Item entity annotate the image with a validation that 
            1. prints the message "Only JPG images are accepted"
            2. only accept values matching this pattern
                      ".*\\.jpg"
          3. In the ItemTest class add a test method test Validation that
            1. saves an Item with a null image
            2. saves an item with an image string ending in .jpg
            3. saves an item with an image string ending in .gif
              1. surround the last save line with a try block
              2. catch a ConstraintViolationException 
                1. add an empty catch block
              3. in the try block add as a last line
              4.         fail("picture.gif should fail validation");
          4. Run the test and correct errors until it succeeds

          19 September 2011

          JPA entity state transitions and EntityManager methods

            • only the most common EntityManager methods/transitions are mentioned
            • void return types have been omitted
            • refresh() is also loading from the database

            18 September 2011

            Java logging toolkit levels mapping

            A comparison of the logging levels (or methods) in different logging toolkits. I omitted the ALL and NONE levels.

            java.util logging log4j/slf4j
            FINEST TRACE
            FINE DEBUG
            INFO INFO
            WARNING WARN
            SEVERE ERROR

            13 September 2011

            What did you do on 9/11?

            I was teaching a Solaris security course that day, with some NATO people in the class.
            I remember meeting my colleague Guido in the corridor saying "World War III just started".
            I told the class the news and went on with the course.
            Next morning, Raoul, manager of Sun Education Belgium, had a minute of silence for everybody.
            One of the British officers told another NATO attendee he should not be wearing a US Army T-shirt, because he was exposing himself as a target.

            8 September 2011

            Reasons to be

            Summer, Buddy Holly, the working folly
            Good golly Miss Molly and boats
            Hammersmith Palais, the Bolshoi Ballet
            Jump back in the alley and nanny goats

            18-wheeler Scammels, Domenecker camels
            All other mammals plus equal votes
            Seeing Piccadilly, Fanny Smith and Willy
            Being rather silly, and porridge oats

            A bit of grin and bear it, a bit of come and share it
            You're welcome, we can spare it - yellow socks
            Too short to be haughty, too nutty to be naughty
            Going on 40 - no electric shocks

            The juice of the carrot, the smile of the parrot
            A little drop of claret - anything that rocks
            Elvis and Scotty, days when I ain't spotty,
            Sitting on the potty - curing smallpox

            Health service glasses
            Gigolos and brasses
            round or skinny bottoms

            Take your mum to Paris
            lighting up the chalice
            Wee Willy Harris

            Bantu Stephen Biko, listening to Rico
            Harpo, Groucho, Chico

            Cheddar cheese and pickle, the Vincent motorsickle
            Slap and tickle
            Woody Allen, Dali, Dimitri and Pasquale
            balabalabala and Volare

            Something nice to study, phoning up a buddy
            Being in my nuddy
            Saying hokey-dokey, Sing Along With Smokey
            Coming out of chokey

            John Coltrane's soprano, Adi Celentano
            Bonar Colleano

            Reasons to be cheerful, part 3 - Ian Dury 

            15 July 2011

            NetBeans, Hibernate and JPA2

            When you create a new persistence unit in a standalone NetBeans project, it only proposes Hibernate with JPA1.
            This is because NetBeans bundles an old Hibernate release.
            To work with Hibernate/JPA2, download a recent Hibernate (>= 3.5) and SLF4J (same version as the one used in your hibernate download).
            Add a new persistence library with these jars from the hibernate installation directory:

            • hibernate3.jar
            • jars from lib/jpa folder
            • jars from lib/required folder
            • an SLF4J implementation library from the SLF4J download, e.g. slf4j-jdk14-1.6.1.jar
              • if you are using ehcache there is no need to download SLF4J separately. It bundles  slf4j-jdk14-1.6.1.jar.
            NetBeans (>= 6.9) will recognize the library as a Hibernate/JPA2 provider.

            7 July 2011

            Mapping the Unified Process to CMMI

            The (Rational) Unified Process (RUP or UP) is an iterative software development process. It was originally developed by the creators of UML at Rational Rose (now IBM).

            CMMI (Capability Maturity Model and Integration) is a model that identifies the characteristics for a good software process within an organisation and defines metrics to be used to measure and improve the maturity of this process. CMMI is developed and governed by the SEI at Carnegie Mellon University. CMMI identifies 5 maturity levels:

            1. Initial
            2. Managed (reactive process)
            3. Defined (proactive process)
            4. Quantitatively managed (measured & controlled)
            5. Optimizing
            The table below how well the Unified Process implements the CMMI constellation for Development (CMMI-DEV). The table below groups the CMMI-DEV process areas by category. The higher the maturity level associated with a process area, the darker blue the background color is. For each process area we show how well UP covers this project area, using a crude High-Medium-Low classification. The table is based on data from SEI and from IBM.



            CMMI Category Process Area Maturity level UP support UP remarks
            Project Management PP Project Planning 2 High only software aspects
            no data management

            PMC Project Monitoring and Control 2 High no data management

            SAM Supplier Agreement Management 2 Low

            IPM Integrated Project Management 3 Medium weak integration of plans and managing dependencies between them

            RSKM Risk Management 3 High should add risk parameters

            QPM Qunatitiative Project Management 4 Low no process decomposition
            no statistical analysis
            Engineering REQM Requirements Management 2 High

            RD Requirements Development 3 High  should add allocating component requirements

            TS Technical Solution 3 High no alternative solutions
            no reuse/build/buy analysis

            PI Product Integration 3 High

            VER Verification 3 High should add recording mechanism for reviews

            VAL Validation 3 High
            Support CM Configuration Management 2 High

            PPQA Process and Product Quality Assurance 2 High

            MA Measurement and Analysis 2 High should add quantitative metrics and analysis

            DAR Decision Analysis and Resolution 3 Low

            CAR Causal Analysis and Resolution 5 Low support for actions on defects and evaluation
            Process Management OPF Organizational Process Focus 3 Low basic support
            OPD Organisational Process Defintion 3 Medium basic support
            OT Organizational Training 3 Low
            OPP Oprganisational Process Performance 4 Low
            OPM Organizational Performance Management 5 Low

            4 July 2011

            Wikileaks sues credit card companies

            We talked earlier about payment clearing houses blocking payments to Wikileaks.
            Wikileaks and their ISP are now suing Visa and MasterCard in Denmark for this action.

            19 June 2011

            Java EE applications, practice 4-2, step 2.g

            1. Retrieve the "customerIdentity" request parameter
            2. Use the identity to look up the customer in the model and save it to the "customer" attribute
            3. Use the identity to look up the customer shares in the model and save them to the "shares" attribute
            4. If there is an exception, save its message to the  "message" attribute

            16 June 2011

            Our new logo











            (thanks to Olivier)

            14 May 2011

            PROTECT IP: new US website blocking bill

            The PROTECT IP act, a new US law proposal, will greatly extend last year's COICA internet censorship proposal:

            • PROTECT IP is targeted at infringement of rights, so it is targeted at distribution of copyrighted material and counterfeited articles.
              • As such there does not seem to be a problem with that, but it remains to be seen how easily this can be stretched. It might be sufficient to find one non compliant item on a site to take action against the entire site. In the past single clips have caused actions against the entire YouTube site.
            • PROTECT IP will no longer try to seize domain names, instead it will target intermediate, servicing sites.
              • This makes it easier to target sites outside the US.
            • Plaintiffs can by simple court order, take direct against revenue sources for these sites (payment clearing and advertisers).
              • The site does not have to be notified to be able to defend itself.
              • The site is notified when action is taken against them starts, if they have an address in the US.
              • There is a procedure to fight the order afterwards.
            • If plaintiff completes a procedure at the Department Of Justice that declares that a site is infringing rights, it can also order the site to be removed from search engine results and ISP hosting.
              • This is a tactic that is copied from the Great Chinese Firewall.
            • PROTECT IP encourages intermediate sites to do self censorship. If Google or Visa stop doing business with a site because they think it is not kosher, they are protected by law
            Full text and petition against the act.

            11 May 2011

            US CERT recommends disabling WebGL

            HTML 5 is sometimes seen as a flash killer, because of the new <canvas> tag. <canvas> can be used to draw graphics via scripting (usually JavaScript).
            Firefox 4 and Chrome 9 support 3D graphics in  <canvas> through the WebGL API. WebGL is developed by the non-profit Khronos consortium, basically consisting of everybody but Microsoft.
            WebGL accesses your hardware driver, giving you hardware acceleration, but also exposing you to a set of vulnerabilities. US CERT now recommends disabling the feature.
            To disable WebGL in Firefox, change the preferences:

            1. navigating to the special about:config URL.
            2. promise to be careful on the warning page
            3. type webgl in the filter bar
            4. toggle the webgl:disabled setting to true

            6 May 2011

            Sun Grid Engine @ Oracle

            Sun Grid Engine used to be available as an Open Source product.
            With the purchase of Sun by Oracle, the product will be called Oracle Grid Engine.
            Future Oracle Grid Engine versions will no longer be open source.The current version of Oracle Grid Engine is 6.2 update 7.
            The Open Source version at the time of the transition (6.2 update 5) was moved to SourceForge and re-branded to Open Grid Scheduler. There is limited activity and progress on the open source project.
            Univa provides commercial support for the open source product at $100 yearly per core. Univa also sells a product with closed source extensions as Univa Grid Engine version 8.

            Oracle recently reversed its policy of commercialising Sun open source projects for some products that successfully forked:

            I doubt that a similar move will happen for Grid Engine

            6 April 2011

            Google App Engine: JPA or Objectify?

            In practice, the biggest difference after abandoning JDO/JPA is that you will stop screaming loudly at your computer, annoying your coworkers.
            Jeff Schnitzer

            25 March 2011

            IPv4 addresses more expensive than .com domains

            Microsoft has bought more than half a million IPv4 addresses from the bankrupt Nortel Networks for 7 million dollar. At $11 per address, this is more expensive than a .com domain name. (although one can argue that it is not more expensive than a good .com domain name).
            IPv4 free address space is depleted since February.

            22 March 2011

            Most teams aren't teams at all but merely collections of individual relations with the boss. Each individual vying with the other for power, prestige and position
            Douglas McGregor

            The system being produced will tend to have a structure that mirrors the structure of the group that is producing it. One should take advantage of this fact and then deliberatly design the group structure so as to achieve the desired system structure.
            Conway's law

            18 March 2011

            Belgian ticket shop Olympic Games 2012 down

            Belgian tickets for the London Olympic games are sold through an online webshop by Suseia.
            The sale started last tuesday night, but could not service the load. It was taken off line and restarted the next morning with doubled capacity. After the relaunch it still had problems and produced all kinds of errors in the sales process.
            The site is now taken offline for more than a month to correct the problems.
            Suseia does not want to disclose the name of the company that built the shop.
            According to a tweet by JF Hovinne, a freelancer and working for Vox Teneo, the site was built with Drupal.

            28 February 2011

            Maven 2.1 site command trouble

            The maven site command allows you to generate project documentation, as explained in an earlier post for maven 2.0.

            Running  mvn:site with Maven version 2.1, I had some problems however:

            1.  site plugin version error
              SiteToolException: ArtifactNotFoundException: The skin does not exist: Un able to determine the release version
              Apparently the skin plugin does not install automatically with a version, so force the issue, from the command line:
              $ svn checkout http://svn.apache.org/repos/asf/maven/skins/trunk/
              $ cd trunk
              $ mvn install -DupdateReleaseInfo=true
            2. doxia ArrayIndexOutOfBoundsException
              [WARNING] Deprecated API called - not org.apache.maven.doxia.sink.Sink
              instance and no SinkFactory available. Please update this plugin.
              [INFO] ------------------------------------------------------------------------
              [ERROR] FATAL ERROR
              [INFO] ------------------------------------------------------------------------
              [INFO] 1
              [INFO] ------------------------------------------------------------------------
              [DEBUG] Trace
              java.lang.ArrayIndexOutOfBoundsException: 1
                      at org.apache.maven.doxia.module.xhtml.XhtmlSink.tableCell(XhtmlSink.java:791) 
              This error is caused by some maven/module version mismatches.
              To solve this second issue, add a <pluginManagement> element under the build element to set compatible versions. <pluginManagement> has a <plugins> child element. Do not confuse this with the <plugins> child of the <buid> element.
              <project>
                 ...
                 <build>
                   <pluginManagement>
                       <plugins>
                         <plugin>
                           <groupId>org.apache.maven.plugins</groupId>
                           <artifactId>maven-site-plugin</artifactId>
                           <version>2.1.1</version>
                           <dependencies>
                             <dependency>
                              <groupId>commons-httpclient</groupId>
                              <artifactId>commons-httpclient</artifactId>
                              <version>3.1</version>
                              <exclusions>
                               <exclusion>
                                 <groupId>commons-logging</groupId>
                                 <artifactId>commons-logging</artifactId>
                               </exclusion>
                             </exclusions>
                           </dependency>
                          </dependencies>
                        </plugin>
                      </plugins>
                  </pluginManagement>
                  ...
               </build>
                ...
              </project>
              
               This modification takes care of the exception, and your documentation generation will succeed. The [WARNING]s above, however, will remain.

            17 February 2011

            6 January 2011

            SearchBlox is free now

            SearchBlox is an easy to use search server based on Apache Lucene.
            It comes as Java web application which you just deploy in your web container.
            Then you configure your search definitions through the web forms in the web application.
            You can integrate with the search engine using a REST based API.
            We have successfully integrated it in customer web sites without any hassle.
            The good news is that from now on SearchBlox is free, as in free beer. It is still closed source however.