Now of course IT isn’t dead in fact I think it’s going to become even more crucial in the near future as integration of technologies, data, and systems becomes necessitated.  However, it’s been quite amazing to see that technology and platform discussions are being had and understood without someone from IT being present.  Business leaders and department managers no longer need to rely on IT professionals to get things done. Deployments are now cloud based and simple.  This is both a good thing and a bad thing.

The good

Since technologies can be deployed by business mangers (or employees), the barrier to get them up and running is quite low.  Years ago in organizations if someone wanted a blog set up it could take weeks or months before from someone from IT could get around to the project, now anyone can launch a blog within just a few minutes without having any type of technical background.  When employees have problems they can quickly turn to technology solutions which best meet their needs.  So, the good news is that anyone can do it at any time in a cost effective and time effective way without dealing with the complexities of IT.

The bad

Since these tools are so easy to deploy organizations can oftentimes run into problems with too many tools being deployed by too many people or departments.  It’s a bit like trying to play “whack-a-mole” with technology.  What happens when one organization starts using dozens or hundreds of solutions each with it’s own data, information, processes, and users?  We start to see duplication of content, lack of standardization, and basically we end up having a big technology mess (which is one of the reasons why IT is needed here).  When it becomes this easy to deploy something the left hand has a hard time keep track of what the right hand is doing.  Just because technologies can be deployed doesn’t mean they should.  Too many solutions just ends up causing more problems and data silos within organizations.

So, what’s the best solution?  Well, it’s hard to say actually, I think it’s a bit too early to tell what the best solution is and I also find that every organization has a different way of approaching their own problems (and they have their own unique problems to begin with).  I suppose every approach has it’s pros and cons.  Do you allow employees to deploy whatever tools they want or do you dictate/advise them on the tools that they should be using?  Both can work and both can fail!

What do you think about where IT needs to fit within social business?

Comments

The event that needs to be focused on is not the former Goldman employee’s stealing habits or the answer to the question on whether it is ok to steal open source code. The astounding news item here is that Goldman is also using open source code which obviously has raised quite a few eyebrows. The reason why I say this is because it is known for a long time now that financial institutions are laggards when it comes to using open source codes due to apparent reasons related to security issues, no accountability, it didn’t give one institution and inherent advantage over another.

It can also be understood that it is not just Goldman which is the only financial institution using open source. The recent period of recession has caused quite a bit of damage to the IT budgets of several corporate organizations and majorly the banking and financial sector, thus forcing them to cut costs.

In view of this objective, financial institutions have taken to open source usage be it Linux, Apache or MySQL. Let me assure you that there is nothing wrong in financial firms using open source, however they are better off sticking to proprietary software systems that guarantee benefits like security, accountability, etc.

In verity many security appliances that are protecting these banks use open source technologies and the end user license agreements dealt with detailing the open source contained on these appliances and warranties that it was used pursuant to license. In addition to this, these firms also built and developed on these open source software and fabricated their own in-house applications. Recession is long gone, albeit the banking sector it seems, has dicovered a new find in open source for the purpose of manufacturing better banking and financial software applications.

Though there was not much noise made about it, the truth remains that financial institutions just like the IT companies have slowly but steadily opened up to the open source fraternity and continue using them for a long time. Sergey Aleynikov, the apparent news making ex-employee of Goldma Sachs, however did not gain any respite as he received punishment of jail-time since not all of the codes that he stole were open source. In the meanwhile, this latest news development has brought into the open that ‘Open Source is not Closed for anyone’.

Comments

Researchers are finding that trends are showing that I.T. professionals are beginning to work for themselves in higher numbers, securing their futures and allowing them to control their own destinies. Geeks, hackers, and I.T. entrepreneurs have been doing this for years, but not in these numbers. While many people think of IT workers as firefighters who fix the everyday absurdities caused from techno-weenies, this is becoming decreasingly true.

While some I.T. professionals have chosen to toil away in poverty stricken anonymity being I.T. drones for large corporations, others have found ways to become I.T. entrepreneurs.

Is I.T. then the entrepreneurial career of the future?

IT Contractors

IT workers, especially developers are beginning to work at home (or the hot tropical country of their choice) due to the highly technical nature of their work and their highly developed specialized skills. As contractors they are entrepreneurs as they lack the full-time tax status of regular workers. These contractors then have the ability to take on multiple jobs, thereby diversifying their career and ensuring higher stability. The top careers for I.T. contract workers are graphic designer, system architects, and programming.

Developers

Developers are the newest form of I.T. entrepreneurs. Consider the explosion of Apps available for iOS and other smartphone and tablet apps. By creating a mindless app like the drunk dialer or the iBanner you can create an on-going income with minimal effort. Others creating larger scale apps like Zuckerberg are able to retire from their innovations.

While none of this is breaking news as every I.T. enthusiast has long been jealous of Zuckerberg’s billion dollar fortune, as trends increase more I.T. workers will be looking to become contractors and developers. I.T. may be one of the first careers to focus more on innovation combined with entrepreneurial skills than on actual work.

For those who think they do not have the resources available to them then consider Fritz Ekwoge, a Cameroon born and based programmer and develop who created iYam.mobi, a mobile phone based directory. Or, look at 15 year old Lachy Groom from Australia who is on her 4th tech startup with her newest project dubbed the iPad Case Finder.

This is exciting news for current I.T. workers who are bored to death at their jobs. The recession is providing the kick-in-the-butt that many high-tech workers need to begin working for themselves, as full-time jobs are decreasing. The good news in this scenario is that most techies already have all the tools they need at home to launch their own entrepreneurial career. So, what is stopping you?

Comments

Develop a Professional Program Management Capability

It was found that program management is sorely lacking in even major acquisitions. For instance, it is often harmful to a persons career to be named a program manager. There is no recognition, benefit, or advancement that can be gained from such a position, thus there is no one person to guarantee continuity from start to finish. Combined with a lack of staff, and a lack of funding, this is an area that needs major improvements.

Promote Agile/Incremental Development

Agile is a method of development that focuses on incremental additions to a project with constant input from the consumer. There is no question how this could be beneficial. The benefits specifically stated in this report are “’Faster to Field’ Deployment, Lower Risk, and Less Rework and Lower Cost.” While agile development is not ideal for all situations, it would be a good thing to implement when it could help.

Strengthen Risk Management

There is no way to reduce risk completely, so this report recommends several things that can help to reduce that risk to manageable levels. For instance, there should be third-party reviews conducted to evaluate performance at any given milestone of a project. There should also be more risk management tools available for use, including experts to be called in when needed.

Enhance Internal and External Engagement

There is nothing more important than good communication, and that is an area that is definitely lacking externally and internally. There is a lack of dialogue between industry and government that is caused by fear. This fear stems from different sources: fear of losing competitive advantages, fear of delivering bad news, fear of favoritism claims, etc. This fear needs to end, and a new system of fear free communication set up to be advantageous for government and industry.

This is just a brief overview of the TechAmerica Foundation report. There are many more issues which were discovered as needing reform, and there are also many insightful solutions to those problems. One thing is for certain, without change things are looking bleak for the future of IT acquisitions by the Federal Government.

For our understanding let us take an excerpt from his explanation and comprehend what NuPack can actually do.

NuPack is a free open source package manager that makes it easy for you to find, install, and use .NET libraries in your projects. It works with all .NET project types (including, but not limited to, both ASP.NET Web Forms and ASP.NET MVC). NuPack enables developers who maintain open source projects (for example, projects like Moq, NHibernate, Ninject, StructureMap, NUnit, Windsor, RhinoMocks, Elmah, etc) to package up their libraries and register them with an online gallery/catalog that is searchable.

Since Microsoft does not specialize in the fabrication of open source software products and services, it comes as quite a surprise that it has chosen open source software to run one of its resources. The idea is for Microsoft’s developers to blend both the open and closed software worlds by writing the open source software and running it under the closed source Windows operating system, wherein the OS is using the proprietary languages and tools. This shall mean that Microsoft can readily sell expensive software to its developer-users and consumers.

The ultimate goal is to make sure that Nupack is seen as an essential element for .Net and is integrated within .Net libraries and projects in the simplest and easiest ways possible with very little complications; in a manner that is supported by all versions of the Visual Studio. A shrewd yet good business sense like always prevails in the Microsoft team enabling more .Net developers to use open source libraries.

There will be a beta launch of the first edition of ASP.Net MVC 3, following the preview of ASP.Net MVC 3. Necessary upgrades have been made to the preview version wherein the Razor engine options shall be improvised, thereby enabling a better MVC integration and best helper methods. In addition to this, there will also be the release of Microsoft’s Webmatrix Beta 2 which caters to the webpage enhancement needs and also improves templates along with facilitating Nupack integration. It is basically used in the development of websites and Windows systems.

All in all, a good and smart move made by Microsoft and this could be one of those occasions whereby a proprietary software maker is using an open software solution to better its products & services and sell them at a luxurious cost.

Comments

In the perfect world, you could deliver this amazing and game-changing solution in a matter of minutes. In the real world, it can take months to years to implement the projects often required of you. The reality of this comes with a crushing knockout blow: the executives of your business want this project completed in the perfect world timeframe. Many IT managers make the mistake of not budging from their estimated timelines. However, coming to the table with your projected timeline and being willing to gravitate toward a timeline that is both realistic and pleasing to the executives is your best course of action.

Emphasize: Quality

If you can emphasize that quality is the desired feature for your particular IT plan, then you can buy yourself some extra wiggle room in your timeline. Although a direct relationship between length of time to implement and quality of the final implementation may not exist, the added time available will allow for more quality through additional planning and testing.

Excel: Follow Through

After a realistic timeline has been established, make sure you follow through. The biggest enemy of IT timelines is you, IT management. Too many IT projects have been pushed backed repeatedly, and this failure to complete projects in a timely fashion has forced many executives to lose trust in IT departments. This lack of trust comes back to bite you when requesting a longer timeframe for a project.

The speed of business is fast paced, but in order to properly assist a company in their goals, we must make sure that we are traveling at a somewhat equal and reasonable speed.

This led to the question, has anyone ever attempted a mapping of IT onto that house? Google isn’t showing me anything.

Being a fool willing to rush in, I played with some concepts top of mind for me lately and came up with the above. Emphasize this is version 0.1, and would really like some feedback.

Some commentary on my choices:

Just In Time has a couple different connotations in light of my dual-axis lifecycle model. Applied to transactional service delivery, clearly the ongoing transition from batch processing to real time service interfaces is exemplary (and obvious). Along the service lifecycle, Agile methods clearly are the major driver to reduce cycle time on systems development at the functional application level. Recently I’ve been playing with a bit of a variation on the Agile theme, as I’ve been contemplating the impact on traditional project management. I’m wondering if we should consider that

• what once was a whole Project, should become a Release;
• what once was a Release, should become simply a Change;
• and what once was a Change, should become simply a Service Request.

The movement of processes and activities through this maturation should be measurable, and clearly (given the relative overheads involved) represents a move towards less waste and greater IT agility.

A major obstacle to this agility has been the provisioning of hardware and base computing services to functional application teams. Internal and external clouds are the just in time response, reducing the time involved in acquiring, installing and configuring base technical capabilities.

Along another dimension, as I thought about what was meant by “quick changeup” in the original Lean (being able to reconfigure a machine tool in minutes not days to produce a different kind of widget) the goals of SOA and even Web 2.0 mashups came to mind. Granular IT services available for arbitrary re-composition enable the same sort of quick change artistry, allowing IT organizations to rapidly recompose solutions to business demand, in days not weeks and months.

On the quality management pillar, one sees test-driven development — essentially the application of poka-yoke principles to software engineering. Contract-based development is a related architectural techique that “that software designers should define formal, precise and verifiable interface specifications for software components” (Wikipedia).

Problem management and root cause are relatively obvious, and attention to non functional requirements will always be a major quality concern.

The idea of data quality driven andon cord is one I am just playing with. Often, process breakage is seen first as a variance in data quality. It seems that there has not been enough said about the opportunities to drive process quality via data quality management. Certainly, if we are serious about process improvement, the accuracy of the data flowing through that process is one of the simplest indicators we have. Applying this to IT management is an area rich for exploration.

Applying “leveled production” to IT management immediately implies some form of demand management, to better pace the work placed on IT resources. Reducing Incidents is of course critical to that, from a waste elimination perspective, as incidents constitute by definition unplanned work. However in my experience another source of thrashing is in the relationship between service providers and customers, especially that relationship playing out along the hosting zone of contention. The dynamics seen in the arm wrestling over prioritizing provisioning requests are exactly analogous to a poorly managed shop floor with competing expeditors seeking to accelerate production jobs out the door. The concept of Critical Chain management is essential, as it clearly outlines both the costs of this dysfunction as well as a sensible approach (now generally accepted by the project management profession) for improvement.

The Scrum concept of fixing the schedule and adjusting requirements to match has clear Lean parallels (and may in fact have originated in the intersection of software engineering and Lean). It is a definitive statement on how to level production in the world of functional application development, and eliminate muri (overburden).

Finally, capacity planning needs to feed more directly into IT financial management; such linkage is not well recognized as an opportunity in much of the IT literature and would give a more stable, pro-active approach for acquisition as opposed to re-active management.

These are some very preliminary thoughts.  This is far from a complete framework. I also realize that the canonical TPS representations include additional layers (e.g. process management, visual management, Toyota philosophy) but I still am thinking about those.

Comments

The report indicated that though most enterprises have long-term plans to continue using Office, alternative productivity tools will remain in the mix by leveraging the tools employees access for do-it-yourself technologies, such as those through mobile devices and the cloud. These evolving productivity tools will help enterprises transform to a fit-to-purpose approach to productivity, establishing the foundation for the next wave of productivity that’s focused on aligning tools with employee needs. In the words of the report, “The next wave of productivity will see today’s innovations dissolve into expected features, creating integrated touch points for content-related activities tailored to fit a business purpose or workforce segment.”

They pointed out that the recent recession has driven interest in free or low-cost alternatives to Microsoft Office and has slowed upgrade plans. In the past year OpenOffice.org has seen a modest uptake by enterprises and is now supported by nearly 10% of the organizations Forrester surveyed. Similarly, cloud-based email from providers like Google is finding traction as a lower-cost alternative to Exchange. I covered the email wars recently (see: Email Wars Heat Up in the Cloud). Google’e move caused Microsoft to drop its prices.

Another factor is the growing interest business process integration and automation, another topic I have discussed here (see for example: Building Enterprise 2.0 into the Product Development Process). As enterprises increasingly use collaboration platforms like SharePoint and the best of breed players, they will (or should) increasingly seek to integrate business content and processes in an effort to move from simple content storage to content workflows. I see this as what needs to be done to really make use of the enterprise 2.0 approach and tools. In a similar way, the only successful KM efforts were aligned to work processes.

There is much more in the report and I found it very useful.  For example, the majority of people surveyed as a background for the report viewed alternatives to Microsoft Office as complementary, rather than replacements. In this light, many tools, including Microsoft Office 2010, are adding social computing capabilities. Other tools such as those from Google, IBM, and Novell are moving in the same direction. 

Comments

Pre-Battle: Planning

A valuable tactic in combating requirements creep is planning. Planning, in this case, would be to properly define the scope of the business process first, and then move on to defining the scope of an IT project. Without knowing the scope and requirements of the business process prior to implementing a technology plan, the initial scope of that business process can creep, and thus force a creep on the IT project.

Battle: Communication

Almost all things in life only get better with increased communication. Implementing an IT project is certainly no different. Constant and thorough communication during all phases of planning, development, testing, and implementation between the IT department working on the project and the business group(s) involved will help clear up any misconceptions and problems. This will prevent large creeps that often happen toward the end of a project when the proper departments are not in the loop and fail to realize problems with an IT project until is more than half-way complete.

Post-Battle: Debriefing

Debriefing gives you an opportunity to close a project. This does not waive any requirements of an IT department to maintain and troubleshoot issues with a project. Failing to close a project and consider it completed encourages requirements creep, as maintenance and feature enhancements arising from continued implementation or changing markets becomes merged into the existing project.

Implement these basic principles in requirements gathering of your next IT project, and you can prevent that project from becoming a small-scale battle to an all out war.

First off, I’m going to assume you already have Java installed and on your path and I’m going to assume you have a Unix-like command line (so this is more for Mac / Linux users – but there is a lein.bat script available for Windows users on the Leiningen site… see below).

The easiest way to get Clojure running is to use the de facto standard build tool for Clojure called Leiningen. So we’ll start by installing Leiningen:

You get Leiningen from github at this URL: http://github.com/technomancy/leiningen

Follow the instructions there to download the lein script and make it executable. Add it to your path (I put it in a bin folder in my user home directory since that’s on my path).

Then get Leiningen to install the bits and pieces it needs to run:

lein self-install

Now you can create a Clojure project, called hello, to play with:

lein new hello

cd hello

lein deps

lein test

You’ll see a single testcase which deliberately fails:

Testing hello.core-test

FAIL in (replace-me) (core_test.clj:6)

expected: false

  actual: false

Ran 1 tests containing 1 assertions.

1 failures, 0 errors.

Great! Clojure is installed in this project and working!

We’ll come back to the project in a bit. To get a feel for Clojure, let’s try out some basic stuff by starting a script console:

lein repl

You’ll see:

Closure 1.1.0

user=>

Type (println “Hello World!”) and press return. You should get:

Hello World!

nil

user=>

Now let’s define a function that does that:

(defn greet[] (println "Hello World!"))

The console will respond:

#'user/greet

user=>

Run the function: (greet)

You’ll get:

Hello World!

nil

user=>

It prints Hello World! and returns no result (nil). Let’s redefine it so it takes an argument:

(defn greet[who] (println "Hello" who "!"))

And now let’s run that:

(greet "Sean")

You should get Hello Sean ! You can type control-D to exit the console.

Now we’ll work on the project we created above.

In your favorite text editor, edit src/hello/core.clj – this is the basic source skeleton that Leiningen created for you above. We’ll add our greet function to it and call it, so core.clj reads:

(ns hello.core)

(defn greet[who] (println "Hello" who "!"))

(greet "Sean")

The (ns hello.core) line declares the namespace (think Java package) in which the code lives.

We can run this via Leiningen:

lein repl src/hello/core.clj

You’ll get the same warning about repl not honoring project.clj options that you saw when you ran lein repl above but you’ll also get your script output.

Now let’s modify our script so we can compile it and run it via Java. First we’ll update the namespace declaration to tell Clojure we want to generate a (Java) class file and we’ll add a main method so Java can call it:

(ns hello.core

        (:gen-class))

(defn greet[who] (println "Hello" who "!"))

(defn -main[who] (greet who))

Note the – in front of the name of the main method. That’s how you declare Java-compatible methods in Clojure.

We also need to tell Leiningen about our new main class. Edit project.clj and add a :main declaration so it looks like this:

(defproject hello "1.0.0-SNAPSHOT"

  :description "FIXME: write"

  :dependencies [[org.clojure/clojure "1.1.0"]

                 [org.clojure/clojure-contrib "1.1.0"]]

  :main hello.core)

Don’t worry about the rest of it – that’s part of the Leiningen / Maven magic used to ensure the right libraries are available.

Now tell Leiningen to compile your script and create a JAR that we can execute via Java:

lein uberjar

If you look in the current directory, you’ll see hello.jar and hello-standalone.jar and it’s the second one we’ll use:

java -cp hello-standalone.jar hello.core Sean

Congratulations! You have a standalone compiled Java version of your Clojure script!

You can read more about Clojure on the Clojure website and the Clojure mailing list. Since the language is still evolving pretty fast, being on the mailing list is pretty much a requirement

Comments