For handsome, smart, educated, awesome, people such as myself, it is a lifetime of treasures, hidden within RSI-inducing key bindings, no matter where on the keyboard one puts C and M.

For leprous, primitivist, stinky, bottom-feeding, monkey-scratchers, it may be a befuddling plethora of options and flexibility that forces the user to form their own opinions regarding the pursuit of goals.

The best description of Emacs I ever read – via comment on HN

As usual, after every milestone I spend some time looking at the history of the project and try to understand my way of working. First question is “when do I work?” – here are some clues I got from the git history of the past 6 months, which included some surpirses:

Commits by Month

December has been low activity month due to various project management reasons, but the major chunk of work has been done in April – which reflects the “integration testing” phase.

Commits by hour

I’m not a morning person – no commits between 4am and 8am. And most of the quick commits happen during the evening, when I settle down into a flow, and evenings are usually me banging head with configuration of JMS Bridges HornetQ, Axis2 and JBoss 7.

Commits by Day

The major surprise for me is that I used to think that I work on weekends, but apparently not much – at least not the features that I can commit quickly. Saturdays are the worst, and on Sunday I usually get back into the groove by evening.

Hourly Commits by Day

2. a professional programmer has a dedication to the end-user experience; most computer applications built these days are Web applications built by small teams and hence it is now possible for an individual programmer to ensure that end users aren’t confused or frustrated (in the case of a programmer working on a tool for other programmers, the goal is defined to be “dedication to ease of use by the recipient programmer”).

3. a professional programmer does high quality work; we preserve the dedication to good system design, maintainability, and documentation, that constituted pride of craftsmanship.

4. a professional programmer innovates; information systems are not good enough, the users are entitled to better, and it is our job to build better systems.

5. a professional programmer teaches by example; open-source is the one true path for a professional software engineer.

6. a professional programmer teaches by documentation; writing is hard but the best software documentation has always been written by programmers who were willing to make an extra effort.

7. a professional programmer teaches face-to-face; we’ve not found a substitute for face-to-face interaction so a software engineering professional should teach fellow workers via code review, teach short overview lectures to large audiences, and help teach multi-week courses.

via Redefining Professionalism for Software Engineers, from 2000.

Served with Jasmin Rice

At one of the AmsClj meetups I floated around the idea of having a meetup for people near Rotterdam and The Hague. After pondering over the thought and some brain storming, I finally got some time to plan and organize the meetup along with fellow Clojure enthusiast Chris Wilson(@minleychris). So we came up with the basic plan for the meetup and named it EHRD.clj.

The Structure

In the footsteps of AmsClj, we plan to have a meetup on last Wednesday of every month for the Clojure enthusiasts in and around Rotterdam and The Hague. It is going to be a semi-structured event which will have two standard recurring features:

1. Library of the Month – A talk/live-coding-session/code-review etc. of a Clojure(Script) Library.
2. This Month in Clojure – Quick overview by a member of the meetup on what happened in Clojure Land in the past month.

Apart from these two, we also intend to have a “main feature” which could be Hacking Session/Presentation or whatever members think interesting.

The first Meetup

For the first meetup on 27th March, we are very excited to announce that Christophe Grand (Clojure core contributor and one of the authors of O’Reilly Clojure Programming Book) will be giving a talk along with our Library of the Month and This Month in Clojure.

This meetup was possible because of the great support and sponsorship of my employer, Lunatech Labs.

So if you are nearby, checkout out our meetup page and kick-off the spring with some good dose of Clojure!

(iterate (str "EHRD.clj monthly meetups"))

Oh yeah, Groningen won with 68 to 66!

package com.vijaykiran.jobs;
 
import org.jboss.solder.beanManager.BeanManagerAware;
import org.quartz.Job;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.spi.JobFactory;
import org.quartz.spi.TriggerFiredBundle;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
import javax.enterprise.context.spi.CreationalContext;
import javax.enterprise.inject.spi.Bean;
import javax.enterprise.inject.spi.BeanManager;
import javax.inject.Named;
 
 
@Named
public class CdiJobFactory extends BeanManagerAware implements JobFactory {
 
   private final Logger log = LoggerFactory.getLogger(getClass());
 
   protected Logger getLog() {
      return log;
   }
 
   public Job newJob(TriggerFiredBundle bundle, Scheduler Scheduler) throws SchedulerException {
 
      final JobDetail jobDetail = bundle.getJobDetail();
      final Class<? extends Job> jobClass = jobDetail.getJobClass();
      try {
         if (log.isDebugEnabled()) {
            log.debug(
                  "Producing instance of Job '" + jobDetail.getKey() +
                        "', class=" + jobClass.getName());
         }
 
         return getBean(jobClass);
      } catch (Exception e) {
         throw new SchedulerException(
               "Problem instantiating class '"
                     + jobDetail.getJobClass().getName() + "'", e);
      }
   }
 
   private Job getBean(Class jobClazz) {
      final BeanManager bm = getBeanManager();
      final Bean<?> bean =  bm.getBeans(jobClazz).iterator().next();
      final CreationalContext<?> ctx = bm.createCreationalContext(bean);
      return (Job) bm.getReference(bean, jobClazz, ctx);
   }
 
}

And here’s a sample Job:

package com.vijaykiran.jobs;
 
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
 
import javax.inject.Inject;
import javax.inject.Named;
import java.util.List;
 
 
@Named
public class TestJob implements Job {
 
   @Inject
   private SomeBean sombean;
 
   @Override
   public void execute(JobExecutionContext context) throws JobExecutionException {
      someBean.doSomethingFancy();
   }
}

There are couple of ways to start the scheduler itself, one was to use a @Startup bean with @PostConstruct method which starts the scheduler and in @PreDestroy, the scheduler is stopped, as shown below:

package com.vijaykiran.jobs;
 
 
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
 
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
import javax.ejb.Singleton;
import javax.ejb.Startup;
import javax.inject.Inject;
import java.util.Date;
 
@Singleton
@Startup
public class CustomJobScheduler {
 
   private Scheduler scheduler;
 
   @Inject
   private CustomJobFactory customCdiJobFactory;
 
   @Inject
   private Logger logger;
 
   @PostConstruct
   public void scheduleJobs() {
      try {
          scheduler = new StdSchedulerFactory().getScheduler();
         scheduler.setJobFactory(cdiJobFactory);
         final JobDetail testJobDetail = JobBuilder.newJob(TestJob.class).withIdentity("test", "test-jobs").build();
 
         final SimpleTrigger trigger = TriggerBuilder.newTrigger()
               .startAt(new Date())
               .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(5))
               .build();
         scheduler.scheduleJob(testJobDetail, trigger);
         scheduler.start();
 
      } catch (SchedulerException e) {
         logger.error("Unable to start scheduler", e);
      }
   }
 
   @PreDestroy
   public void stopJobs() {
        if(scheduler != null) {
           try {
              scheduler.shutdown(true);
           } catch (SchedulerException e) {
              logger.error("Unable to stop scheduler", e);
           }
        }
   }
}

The other approach is to start the scheduler when the Webapplication has started using the CDI Event listener mechanism.

package com.vijaykiran.jobs;
 
 
import org.jboss.solder.logging.Logger;
import org.jboss.solder.servlet.WebApplication;
import org.jboss.solder.servlet.event.Destroyed;
import org.jboss.solder.servlet.event.Started;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.SimpleTrigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
 
import javax.enterprise.context.ApplicationScoped;
import javax.enterprise.event.Observes;
import javax.inject.Inject;
import javax.inject.Named;
import java.util.Date;
 
@Named
@ApplicationScoped
public class CustomJobScheduler {
 
   private Scheduler scheduler;
   @Inject
   private CdiJobFactory cdiJobFactory;
   @Inject
   private Logger logger;
 
   public void onStartup(@Observes @Started WebApplication webapp) {
 
      try {
         scheduler = new StdSchedulerFactory().getScheduler();
         scheduler.setJobFactory(cdiJobFactory);
         final JobDetail testJobDetail = JobBuilder.newJob(TestJob.class).withIdentity("test", "test-jobs").build();
 
         final SimpleTrigger trigger = TriggerBuilder.newTrigger()
               .startAt(new Date())
               .withSchedule(SimpleScheduleBuilder.repeatSecondlyForTotalCount(5))
               .build();
         scheduler.scheduleJob(testJobDetail, trigger);
         //Start the scheduler a minute after the webapplication is started.
         scheduler.startDelayed(60);
 
      } catch (SchedulerException e) {
         logger.error("Unable to start Scheduler ", e);
      }
 
 
   }
 
   public void onShutdown(@Observes @Destroyed WebApplication webapp) {
      if (scheduler != null) {
         try {
            scheduler.shutdown(true);
         } catch (SchedulerException e) {
            logger.error("Error while shutting down scheduler", e);
         }
      }
 
 
   }
}

Happy new year!

Here are some photos I took during the photoshoot near EYE film museum in Amsterdam.

Video on youtube

→ Straight Dope on how to transmute base substances into gold

The great inventor Thomas Edison visited the home of Mark Twain in 1909, and captured footage of “the father of American literature” (says Faulkner) walking around his estate and playing cards with his daughters, Clara and Jean.

Mark Twain Captured on Film by Thomas Edison (1909) | Open Culture.

Since Emacs 23.2, eshell has also an own implementation of the su and sudo commands. Both commands change the default directory of the *eshell* buffer to the value related to the user the command has switched to. This works even on remote hosts, adding silently a corresponding entry to the variable tramp-default-proxies-alist (see Multi-hops):

~ $ cd /ssh:user@remotehost:/etc 
/ssh:user@remotehost:/etc $ find-file shadow 
File is not readable: /ssh:user@remotehost:/etc/shadow
/ssh:user@remotehost:/etc $ sudo find-file shadow 
#
 
/ssh:user@remotehost:/etc $ su - 
/su:root@remotehost:/root $ id 
uid=0(root) gid=0(root) groups=0(root)
/su:root@remotehost:/root $

Via: Running eshell on a remote host

People who constantly try to always get that great deal end up spending all their time chasing those deals and never actually get things done.  I’ve seen people do this their entire lives, and it is debilitating.

When we change your mindset from getting the best deal to getting the best quality, it changes the emphasis from shopping to deciding what’s important.  Because we only buy quality, we are forced to wait until we can afford what we really want.  That wait time leads to better decisions, and it forces us to make do with what we have.  Often making due or improvising means we can avoid buying things we don’t need, thereby saving money.

via Pay Too Much | ALLENTUCKER.

Last year I succeeded in growing tomatoes at home which were pretty tasty and good. This year to continue the tradition I started growing Two types of tomatoes, artichokes, aubergines and bottle gourd. This year I have setup a special website for the timeline – garden.vijaykiran.com. Last year most of the plants have been grown in different pots. This year, I got bigger styrofoam pots in which I’m growing at least 8 plants in one. So far the plants are healthy and tomatoes, bottle gourds started to appear already.

Here are some photos: