Skip to content

Java Version History

JDK 1.0 (1996)
JDK 1.1 (1997)
J2SE 1.2 (1998) – This and subsequent releases were rebranded retrospectively Java 2.
J2SE 1.3 (2000)
J2SE 1.4 (2002)
J2SE 5.0 (2004) – Originally numbered 1.5
Java SE 6 (2006) – As of this version, Sun replaced the name “J2SE” with Java SE and dropped the “.0” from the version number
Java SE 7 (2011) – Oracle bought Sun System

Java SE 8 (2014) –  Lambda expressions (closures) Joda Date/Time Api

Java SE 9 (2017) – ?

Advertisements

Note Taking Rant

OK sorry; so here’s a rant:

Having moved from windows to using Linux mint for my work; the first thing I started to do (and got frustrated with) is to find a decent note taking tool on Linux something that’s equivalent to Evernote client on Windows.

I simply couldn’t find something the does exactly what I wanted it to do; a tool which:
a) Works on Mint Petra !!
b) Provides easy  search functionality
c) Allows multiple level of folder hierarchy
d) Keep syntax highlighting out of the box
e) Allows images

basically what I was looking for something like Evernote … and please don’t make be tempted to use Evernote online !!!!

My primitive trail of note taking tools:

Springseed – Clean interface like the Dropbox sysnc option | no search, Notes not formatted well in preview mode and sometimes lose their formatting; flaky
Everpad – Not even close |  again no easy search  | trouble keeps notes synced where deleted notes start appearing
NixNote – Clutter fuck; I don’t want to even begin with what’s wrong with this; very disappointing
Tomboy – Very primitive but did what I wanted it to do
TeXStudio
Notecase pro – Not free
rednotebook

Springpad?

Ps Hubmle apologists if you worked on any of these projects or liked those; I mean no offense really; just wanted something that suited my needs.

Rant over !!!

Loging Levels

Most logging frameworks (Logback, Log4J, JDK Logging) have them; but are we using them correctly? When is it a WARN instead of an ERROR; should DEBUG be used or TRACE and what about INFO?

Not logging at the right level could render what potentially might be useful logs into swaths of pointless bytes accumulating diskspace for no reason. The result is no-one bothers to look at the logs cause “they’re a pile of sh*t“.

SO here I’ve outlined some rules of thumb that I use for my projects when logging:

ERROR: The system is in real distress and an urgent fix WILL be required IMMEDIATELY. Customers are probably being affected. The “2:00 AM rule” applies here; if you’re on call, do you want to be woken up  if this condition happens? If yes, then definitely log me as “ERROR“.

WARN: An unexpected technical or business event happened. Somme customers might be affected slightly but the applications major functionalities are still operational. No immediate intervention is required. Should the person on call be woken up? If “no” then it’s a “WARN“; but support personnel will want to review this issue ASAP to understand what’s the impact. Basically any issue that needs to be tracked and acted upon but may not require immediate intervention.

INFO: Things of high volume such as system event life-cycles (start-up, shutdown) go here. “Session” life-cycle (login, logout, etc.). Boundary events should be considered as well (e.g. API calls, database calls). And typical business exceptions that is NOT an error can go here (e.g. login failed due to bad credentials). Is this a normal event/transition that could occur? If “yes” then log as INFO.

DEBUG: Any message that is helpful in tracking the flow through the system and isolating issues, especially during the development and QA phases. Is this information interesting for programmers? If “yes” then log it as DEBUG.

TRACE: Not often used but extremely useful for detailed logs. Typically not enabled during normal development but nevertheless necessary in case the system needs to be forensically analysed. Examples include dumping a full object hierarchy, logging every state during loop iterations etc. Need to analyse in detail the flow of a program; if the “yes” then use TRACE.

Hope this has helped you; any suggestions/improvements welcomed as ever 🙂

Quote

“Clean Code Gems”

Having read Robert C. Martin “Clean Code – A Handbook of Agile Software Craftsmanship” back in 2010 at the time I didn’t really appreciate much of the gems raised and I skimmed through much of the book. At first glance my initial thoughts were that this book just had some well known common sense basic programming practices that every newbie would know. To a certain extent this was true but

Many years on I am back to this book; this time having read it cover to cover I realised how beautifully clear and simple these basic programming concepts are portrayed. Although what is said in essence is general coding practices that we all love and adhere to; having these written down in such a clear manner is very useful. The book has become one of my favorites and I now recommend this book to every programmer.

Below I’ve listed some of the simple rules that one should aspire to while writing code.

  • Method & classes should have meaningful names.
  • Methods should be SMALL and do ONE thing ONLY.
  • Switch statements should be avoided unless absolutely necessarily and if used they should be buried deep in the code and never repeated.
  • Function arguments the less the better; the best functions are those with clear names and no arguments at all.
  • Return exceptions rather than error codes.
  • Comments are necessary evil … use only if it’s a legal requirement/warning/must have amplification/TODO comments and public API comments.
  • Separate business logic from error handling.
  • Methods should NOT return null.
  • Obey the three laws of TDD.
  • Classes should have single responsibility as with functions.
  • Maintaining cohesion results in many small classes
  • Concurrency: limit scope of updated data
  • Use thread safe collections
  • Default constructor no use
  • Avoid feature envy classes
  • If order of functions is important, temporal coupling should be enforced.

… examples of bad code to go along with it.

Final Note

This book is well worth a read. For a new developer it’s an absolute must. For experienced developers it servers as a good refresher of the how code should be crafted. I know by obeying those gems above has helped me greatly.

For further evidence read this post: (Why clean code is more important than efficient code)

Read more…

PRINCE2 & AGILE … the philosophies

The software perspective:

In the field of software development having worked with different teams in projects employing both these two methodologies; I thought it would be good to write a small blog on the different approaches these two techniques adopt to solve the conundrum of producing successful software.

My prospective comes from being a software developer and not the actual project manager; hence I WILL be heavily biased towards the development team.

A little background:

First off it must be pointed out that PRINCE2 is a project management framework; while agile methodologies deal more with the particle side of software life cycle; hence comparison between the two is slightly skewed pending on what you are comparing. The blog will examine at a high level the different philosophies used by each to develop software.

PRINCE2

PRINCE2 is an acronym for “PRojects IN Controlled Environments” (version 2). It is a generic project management methodology used for exercising control over a project by setting out the major components of a project. It has a definitive set of processes that should be followed and adhered accompanied by documentation.

Although it originated in IT although the current version makes no reference to IT and indeed it can be used for all sorts of projects. Heck you can even used it to plan your next shopping trip but I wouldn’t recommend it. At stated in the introduction this blog focuses on using PRINCE2 as a tool for delivering software. More can be found on PRINCE2 [Here1] [Here 2] and [Here 3]

Capture

Figure 1: Process workflow of a typical PRINCE2 project

AGILE

On the contrast agile software development refer to a group of software development methodologies principally based on iterative and incremental development. In agile, requirements and solutions evolve over time through collaboration; focus is given to frequent deployment with quick feedback loops over processes and tools such as those imposed by PRINCE projects. More can be found out about the philosophy of in the agile manifesto and other resources [Link 1] [Link2].

Capture2

Figure 2: Process workflow of a typical agile project

The philosophies:

PRINCE2 takes a very process oriented approach to software development – as evidenced by the 7 processes. In many ways the conventional waterfall model is akin to this liner approach whereby components follow after another with documentation covering the each step. Therefore projects in PRINCE2 define what is to be produced before any work is performed backup by the business case.

In my view this leaner process oriented approach is indirect conflict with several key principles of agile development namely:

(1) Individuals and interactions over processes and tools

(2) Working software over comprehensive documentation

(3) Customer collaboration over contract negotiation

(4) Responding to change over following a plan

Agile methodologies emphasize on close collaboration between the development team and business experts using face-to-face communication rather than using a formal structured processes such as those employed by PRINCE2. The focus of agile techniques is on delivering frequent features that add value to the business and to provide quick feedback to on those features. There is no formal process that govern how the team operates, hence leaving the team to “self-organise” and craft the code and achieve its goals on its own. Documents aren’t created for the sake of documents.

From experience:

Creating software is dynamic and ever changing process. Quite often what you find is that end users don’t really know what they are looking for until they actually started using the product. What at the start of the project might seem as a ‘MUST HAVE’ feature might in the end up as a nice to have or even replaced by some other component altogether. Clients often don’t know what they want or need until they actually see working software.

Due to this dynamic nature of software making accurate design prediction at the start of the project becomes very hard and any predictions are usually unsurprisingly incorrect. Where the PRINCE2 approach fails in software development I believe is in the ‘big design up-front’ approach. The fact that every requirement of the system needs to be documented on the onset makes huge assumptions before any code is written. Any deviation from this original plan involves a heavy handed approach to keeping everything aligned*. PRINCE2 sees change as something to be minimised and managed rather than be recognised it as an integral part of the creative working software.

PRINCE2 approach works well if the software being developed is well define and the requirements are exact and certain not to vary widely during the project… having a processes to guide such development might not be such a bad idea. But in reality this isn’t the case; specing out the details of a complex project is very hard especially when new features and third part integration is involved.

One important point here to make is that while PRINCE2 has been applied to various industries for various size projects this cannot be said for agile progresses. (You wouldn’t build a nuclear sub on agile principles, would you?); having said that you might build a Toyota.

Due to this different philosophy these two approaches aim to tackle the creation of software in a totally different manner and at the moment I am an agilest… what’s your thought?

Welcome your comments/thoughts/improvements 

Also look at:

ITIL, DSDM,   RUP, SSADM, PMP

Eclipse optimisation (3 Simple Steps)

To my mind the new version of Eclipse (Juno) seems to be running a little slower than Indego.

Here is a list of things you can try to enhance performance:

1)      The standard; configuring the C:\eclipse\eclipse.ini to allocate more memory on start up.

 

–vmargs

-Xms512m

-Xmx1024m

 

2)      Turn off any validators that you do not need. ‘HTML Syntax Validator’ is a big culprit.

 

Windows –> Preference –> Validators

 

3)      Deactivate plug-ins that you don’t currently use. I’ve found the ADK particularly resource hungry.

 

Widows –> Preference –> Startup and Shutdown

 

I also found that using the latest JDK makes some difference.

 

Hope this helps; any other suggestions welcomed

It’s better xxxless if (var xxx = wire)

Designed for humans, inspired by wireless charging

– 4.8″ screen – is a nice to have

– voice control – siri iPhone done before

– 4G support – not that exciting

– peer-to-peer connection – never going to use that

– Bluetooth and NFC (Near Field Communication) – comes as standard right

Wireless charging – What! What’s that you say “wireless charging” now that should get your attention.

Yes the Samsung Galaxy S III comes with wireless charging (AKA inductive charging); a feature which I think should raise a few eyebrows. But hold off before you go buying; apparently the wireless kit won’t hit the shelves till sometime in September when we can all try cable-free changing.

Yes the Samsung Galaxy S III comes with wireless charging (AKA inductive charging); a feature which I think should raise a few eyebrows. But hold off before you go buying; apparently the wireless kit won’t hit the shelves till sometime in September when we can all try cable-free changing.

Wireless chaining will be the benchmark for future phones and other devices. Wouldn’t it be great that as soon as you enter the house your phone starts charging just in time for you to pick-up the phone on your night out fully loaded ;). Humans are lazy & any technology employed to make our lives easier is bound to succeed.

Beach time

But don’t go off hitting the beach just yet: the drawbacks

–          Range: not far really

–          TIME: it will take longer MUCH longer to charge the phone

–          It will use more power hence a lot is wasted

–          Even less compatibility then there is now wit cables

–          Cost: Generally you would have to buy the changing kit separately and it won’t come cheap

–          I don’t one can use the phone and charging at the same time wirelessly

Note: Inductive charging is nothing new; Palm Pre has this back in 2009 and GM already had this install in Chevy Volt back in June 2011. The technology is widely used in artificial hearts and other surgically implanted devices. Even Oreal B toothbrushes where using it back in the early 1990s but because of the drawback stated above it never really took off in mainstream markets; so let’s hope that Samsung don’t make a hash of it.

The key for me is; as always; is PORTABILITY; if this established (which at moment is unlikely) then there will be a huge boom in devices which support this type of inductive charging. All of the drawbacks stated above will be overcome in time but the sticking point will be portability. Images ALL your devices charging wirelessly from one hub… there a thought.

Whether you like tor not wireless charging will be the thing for the future and not just for mobile phones; think of every device that has a cable and cut it off.