Speed up your dev cycle with git
Posted by Iwein Fuld at around evening time: February 28th, 2010
Git has made me more productive, and I will explain in a few words why that is. I could almost do it with twitter, but I like to take a little more time to make my point. The main benefit that git has given me can be found in performance of certain things I want to do when I am managing changes in my code base. The performance improvements of some critical parts of it are even so profound that they have changed the way I am working. In particular the fact that I can skip builds for most of my commits is a big time saver.
There have been many things said about git already and I suggest you use your favorite search index to bring yourself up to speed if you need to. Git is a simple distributed versioning system that is challenging many assumptions I had about development. Let's go over these assumptions. I'll show you my (svn based) assumption and why it doesn't hold if you're using git.
(more...)
Web performance in seven steps: Summary and Conclusions
Posted by Jeroen Borgers at around evening time: January 20th, 2010
Previous time I blogged about the last step of the seven steps, step 7: Share the responsibility for the whole chain, a non-technical but rather a communication and behavior thing which I found crucial for success. We now have reached the end of this series and I'll sum up the topics we've dealt with and draw some conclusions. (more...)
Web performance in seven steps; Step 7: Share the responsibility for the whole chain
Posted by Jeroen Borgers in the late evening: November 18th, 2009
Last time I blogged about performance tuning based on evidence, the tuning cycle and some best practices. This time I'll blog about the last step of the seven steps: sharing the responsibility for the whole system chain.
When an incident happens in production, this usually means stress. A performance problem in production often leads to finger pointing. (more...)
Web performance in seven steps; Step 6: Tune based on evidence
Posted by Jeroen Borgers in the late evening: November 2nd, 2009
Last time I blogged about the relevance of monitoring and diagnostics in production to solve incidents quickly and prevent future problems. This time I'll talk about tuning based on evidence.
If an application turns out to be too slow, tuning can provide a solution. Tuning can take place on multiple levels. Adding hardware can be a cheap solution. However, when you add hardware at a place where the bottleneck is not located, this has little use.
(more...)
Web performance in seven steps; Step 5: Monitor and diagnose
Posted by Jeroen Borgers late at night: August 31st, 2009
Last time I blogged about the importance of continuous performance testing. When you write and run performance tests continuously, just like unit tests, you get early performance insights in new and changed features of your software. This will minimize surprises and be more productive. Now I’ll blog about monitoring and diagnostics.
When a new version of the software is released into the production environment, the question always is: will it actually perform like we saw in testing and acceptance environments? And we keep our fingers crossed.
(more...)
Web performance in seven steps; step 3: test representatively
Posted by Jeroen Borgers at around evening time: June 29th, 2009
Last time I blogged about the importance of benchmarking the architecture and new technology in a Proof of Concept for Performance. This time I’ll deal with the importance of representative performance testing.
Slowness of applications in development environments is often neglected with the rationale that faster hardware in the production environment will solve this problem. However, whether this is really true can only be predicted with a test on a representative environment and in a representative way. In such an environment, there needs to be more representative than just the hardware.
(more...)
Understanding Google Wave
Posted by Sonny Gill mid-morning: June 8th, 2009
(This blog post gives an overview of the architecture and technical concepts in Google Wave. If you are interested in how to use Google Wave in your applications, see Developing with Google Wave)
At Google I/O 2009, Google unveiled Wave. Wave is a new way of thinking about online conversations.
Consider the following situations -
- You write a blog post. Somebody comes around and posts a really insightful comment. Now, you or the comment author want to convert that comment into an independent blog post.
- You have been having a long email discussion with a colleague. Now you would like to invite another colleague to the same. She will need to know the context of the discussion and how it evolved.
- You email a few colleagues a draft of an article for review. They all email their comments back to you. A lot of them are suggesting the same changes without realizing that they have already been addressed.
With the tools we are using today such as email, blogs, IM etc., all of the above will require some kind of tedious copy - paste, and manual tracking of the changes being made.
Is there a better way?
The Google Wave model tries to provide a better way (more...)
HSQLDB “database already in use by another process” exceptions on UNIX
Posted by Andrew Phillips mid-afternoon: March 20th, 2009
Installing a simple Grails application in Tomcat on Linux should really have been the most straightforward of tasks. Instead, I spent a progressively more frustrating morning chasing down a "helpful" feature of HSQLDB that was causing the startup to fail with
org.hsqldb.HsqlException: The database is already in use by another process: org.hsqldb.persist.NIOLockFile@6b67bdbe[file =/myDb.lck, exists=true, locked=false, valid=false, fl=null]
exceptions. To save others from a similar waste of time, here's the cause and a workaround: (more...)
GIT 101
Posted by Age Mooy in the wee hours: January 26th, 2009
After hearing a lot about distributed source code management (SCM) systems lately, I've been playing around with GIT and I like it a lot. As a longtime user of traditional SCMs like CVS and Subversion, working with GIT is something of a revelation and so nothing seems more natural than spreading the gospel a little 
To help other people learn about GIT, I've collected some of the most interesting GIT 101 stuff I've found around the net.
Flex Testing Toolkit
Posted by Abhishek Agrawal in the late evening: November 19th, 2008
My recent assignment at Albumprinter gave an opportunity to play with flex testing tools available out there. Coming back to serious flex development after more than a year was a pleasant surprise. The state of flex when I last did something on it was for sure not “mature”. There weren’t many frameworks around.
But things have changed a great deal since then. Not only do we have frameworks implementing MVC (Cairngorm) but also some standard extensions (UM extensions) to those frameworks, we also have spring like IOC frameworks (Prana) for Flex.
(more...)
Archives
Xebia Sites
Categories
- Java (282)
- Agile (109)
- General (50)
- Testing (42)
- Performance (42)
- Hibernate (36)
- Scrum (33)
- Podcast (31)
- Architecture (31)
- Spring (28)
- SOA (24)
- Maven (22)
- Project Management (22)
- Middleware (23)
- Deployment (14)
- Flex (17)
- JPA (17)
- Eclipse (15)
- Xebia Labs (15)
- Quality Assurance (14)