wiserwinds

LEAN: 5S According to me. An Innovative Thought

2019-05-14T02:49:00.002-07:00

According to standard definition, the term 5S comes from five Japanese words:

Seiri
Seiton
Seiso
Seiketsu
Shitsuke

In English, these words are often translated to:

Sort
Set in Order
Shine
Standardize
Sustain

But I would like to re-define 5s as follows

Simplify: To understand the work need to be done and simplify the work in smaller chunks.
Sort: Once simplified, arrange in order on how to tackle the chunks of work to accomplish the main stream work that is simplified.
Simulate: Try to attack in various conditions and situtations by creating various situations by simulating the workflow. Understand the outcomes and enhance the process from learnings through simulation.
Speedup: Speedup the process to produce better for demand and supply
Survive: Survive by acting to the customers’ demand and support them as per the need.

Why is it important for me?

The above define 5s’ help any product to start off from the scratch and help build innovative products by accomplishing smaller chunks of work (simplify), arrange them (sort), test the pices of work done in various conditions (simulate), gain cognition on the work done (speed up) and continue their existence in the marketplace (survive).

Do you have a new definition of your 5s? Mention them in the comments and describe why it is important for you?

By,

Navule Pavan Kumar Rao

TAKT Time Demystified

2019-05-14T02:40:00.003-07:00

Lets go through the definition of TAKT time and how it is calculated with a real-time example.

Definition of TAKT Time:

TAKT Time is defined as the ratio of available minutes to the required units of production.
Mathematically it is defined as follows:

TAKT Time = Available Minutes for Production / Required Units of Production per day

Available time is the actual time spent on production activity. It does not includes meetings, administrative non-working time, tea breaks and lunch breaks.

Calculate TAKT Time Step by Step (A real-time Situation):

Assume a situation where in you want to release a plugin to enterprise dealers. Provided there are 300 roof tops for this dealer to which this plugin needs to be released for. The Client Account Manager has set a target of 60 roof tops per day so that he wants to complete all roof tops released with the plugin within 5 days. Then the Takt time can be calculated here as following:

From the definition of Takt time, An employee works 8 hrs a day. 8 hrs = 480 mins

Tea breaks= 10mins ( 2 breaks of 5 mins each)

Daily standup = 30 mins

Available Minutes for Production = 8 hrs a day – (Tea Breaks + Daily Standup meeting)

= 480 mins – (10 mins + 30 mins)

= 440 mins

Available Minutes for Production = 440 mins

Plugin needs to be released for 60 roof tops per day, which means

Required Units of Production per day = 60

TAKT Time = 440/60 = 7.33 mins

This implies that a release for every roof top should be completed with in 7.33 mins or precisely 440 seconds, to reach the goal of 60 roof tops per day.

This is ideal situation provided that there are no unforeseen situations like connectivity issues, network outages.

By,

Navule Pavan Kumar Rao

A wonderful dream, That I'll never forget

2014-02-16T11:03:00.011-08:00

Feb 16,2014 - A wonderful day in my life..I got a dream wherein I was on a mission to reach the Moon on a space shuttle and come back to the Earth from the Moon via a specially designed bicycle, riding it on a rope that was tied between the Earth and the Moon. Everything appeared to be in a High Definition in the dream. I was clearly able to visualize the every detail including grey colored dust on moon that fell on the bicycle which was already arranged for me on the Moon.

I landed on the moon and removed my astronaut's suit. It was the night on the Moon with sufficient amount of brightness and glow of the Sun rays reflecting all over it. I wondered how I was able to breath. As soon as I mooned (landed as on earth) I saw a vegetable market full of vendors shouting on a sale.

Suddenly I was distracted by two kids running one after the other and I kept following them. They took me to the bicycle and the place where a rope was tied from the Moon to the Earth. I took the bicycle and was full of confidence even though there is a chill on my spine. I put the front tire of the bicycle on the rope.. Its my alarm started buzzin'.. its 8.00 am in the morning..

Update(17/02/2014):
The reason I got this fantasy dream is just because I had seen the Moon in the deep blue clear sky that night. Actually the pics above were taken on the later night as usual when I was returning back to my bed, I abruptly had to see this beautiful view of the moon and recalled that 'I had seen much more beautiful view yesterday'.

One more strong reason for this extreme fantasy dream could be due to the fact that I was frequently listening to 'Poore chand' song from Ram-leela movie now a days (I didn't yet watched the movie though!!). Probably this could also been one of the motivating factors for the dream that I got.

Update(27/03/2023):

We now have Bing image creator powered by DALL-E and the images generated were so true to match the imagination given the phrase "a high detailed view from the bicycle overlooking a rope that leads it's path from the Moon down to the Earth". A great thanks to DALL-E and Bing image creator.

Enabling Full Text Search on Godaddy

2013-09-25T13:40:00.002-07:00

GoDaddy full text search with MS SQL Server

1.Choose Table and find its Primary Key

1. Find the name of the primary key for the table that you want to index. My table name is "content" and the key looks like this: PK__fields__0xxxx

Create table content (

Pagename varchar(20) not null primary key,

URL archar(30) not null,

Description text null,

Keywords varchar(4000) null)

2. Create Full Text Index

CREATE FULLTEXT INDEX ON [content]
KEY INDEX [PK__fields__0xxxx]
WITH CHANGE_TRACKING AUTO

3. Add column(s) to the index

EXEC sp_fulltext_column 'fields', 'Pagename', 'add'

EXEC sp_fulltext_column 'fields', 'URL', 'add'

EXEC sp_fulltext_column 'fields', 'Description', 'add'

EXEC sp_fulltext_column 'fields', 'Keywords', 'add'

However its bad practice to enable all columns with full text indexing which significantly poses performance threat to the SQL Server. For more details you can google the best practices for full text indexing on the internet.

4. Activate index

EXEC sp_fulltext_table 'content', 'activate'

5. Start index population (if not started)

EXEC sp_fulltext_table 'content', 'start_full'

6. Enjoy full text search in your ASP.NET application

SELECT FREETEXTTABLE(content, description, @query, 100)

Below are some more examples you can check around.

Query 1 (FREETEXT)

SELECT * FROM content WHERE freetext(*,"home")


Result
Pagename	URL	Description	Keywords
--------	---------	---------------------	---------
home.asp	/home.asp	This is the home page	home, SQL

This queries all full-text-enabled columns in the content table for the string "home."

Query 2 (FREETEXT)

SELECT * FROM content WHERE freetext(description,"Magazine")


Result
Pagename	URL	Description	Keywords
--------	---------	---------------------	---------
Pagetwo.asp	/page2/page2.asp	NT Magazine is great	second
Pagethree.asp	/page3/page3.asp	SQL Magazine is the greatest	third

This only searches the Description column and returns all matches for the string "Magazine."

Query 3 (FREETEXT)

SELECT * FROM content WHERE freetext(description,"SQL Mag")


Result
Pagename	URL	Description	Keywords
--------	---------	---------------------	---------
Pagethree.asp	/page3/page3.asp	SQL Magazine is the greatest	third

Although this appears to search on the string "SQL Mag," it actually searches on "SQL" or "Mag."

Query 4 (FREETEXT)

SELECT * FROM content WHERE freetext(description,"the")

Result

Server: Msg 7619, Level 16, State 1, Line 1

The query contains only ignored words; we've queried a noise word here. You'll find "the" in the noise words file at \MSSQL7\FTDATA\SQLSERVER\CONFIG.

Query 5 (CONTAINS)

SELECT * FROM content WHERE contains(*,"home")


Pagename	URL	Description	Keywords
--------	---------	---------------------	---------
home.asp	/home.asp	This is the home page	home, SQL

Like the Freetext query, this searches all full-text-enabled columns for the keyword "home."

Query 6 (CONTAINS)

SELECT * FROM content WHERE contains(Description,'  "Magaz*"  ')


Pagename	URL	Description	Keywords
--------	---------	---------------------	---------
Pagetwo.asp	/page2/page2.asp	NT Magazine is great	second
Pagethree.asp	/page3/page3.asp	SQL Magazine is the greatest	third

This statement queries the Description column for a word beginning with "Magaz." Note that the asterisk acts as a wildcard or placeholder, just as the percent sign (%) does with the LIKE keyword. (To make this work, you need to use single quotes on either side of the double quotes.)

Query 7 (CONTAINS)

SELECT * FROM content WHERE contains(Description,'  "*azine"  ')


Pagename	URL	Description	Keywords
--------	---------	---------------------	---------

This search yields no results. You can't use an asterisk as a placeholder for a prefix.

Query 8 (CONTAINS)

SELECT * FROM content WHERE contains(Description,'  "Magazine" Or "Great"  ')


Pagename	URL	Description	Keywords
--------	---------	---------------------	---------
Pagetwo.asp	/page2/page2.asp	NT Magazine is great	second
Pagethree.asp	/page3/page3.asp	SQL Magazine is the greatest	third

This full-text scan uses OR so that you can search for "Magazine" or "Great"; it also works with AND and AND NOT. (Again, note the single quotes around the search criteria.)

Query 9 (CONTAINS)

SELECT * FROM content WHERE CONTAINS(description, 'NT NEAR great')


Pagename	URL	Description	Keywords
--------	---------	---------------------	---------
Pagetwo.asp	/page2/page2.asp	NT Magazine is great	second

This search on the Description column finds all rows where "NT" is near "great".

Query 10 (CONTAINS)

SELECT * FROM content WHERE contains(description, ' formsof (inflectional, great) ')


Pagename	URL	Description	Keywords
--------	---------	---------------------	---------
Pagetwo.asp	/page2/page2.asp	NT Magazine is great	second
Pagethree.asp	/page3/page3.asp	SQL Magazine is the greatest	third

This statement returns all results for "great," "greatest," "greater," and so on.

Sources: http://codeshard.blogspot.in/2011/10/godaddy-full-text-search-with-ms-sql.html

http://sqlmag.com/sql-server/sample-full-text-search-engine

5 Ways to express Love to your beloved Child. -For Dummies.

2012-02-28T02:12:00.001-08:00

Here are the five ways to express your child when you feel you are not doing so!!

1. Go to your child when sleeping in the morning when it is time to wake up and tingle your child's ear with your hair and hide by side.
And when your child looks around give a surprise.

2. Keep a habit of making nosy nosy between you and your child. It means gently rubbing your's and child's nose to each other. This will increase the affection between both of you.

3. Say "I Love You Baby" atleast once a day to your child.

4. Don't forget to say "I miss you" when your child is going to mall or shopping with his/her dad.

5. Kiss and appreciate when your child did a great job even though it is very small from your perspective.

BY
N PAVAN KUMAR RAO

GOOD MORNING WORLD

2011-06-14T18:30:00.000-07:00

J GOOD MORNING J

Days pass by your life very fast..

Enjoy your life as today is your last..

May this Morning bring in your day a BIG BLAST!!!

JJJ

N Pavan Kumar Rao

Evolution Of Delegates from .NET 1.x to 3.5 including Code samples.

2011-06-14T06:30:00.000-07:00

Delegates were introduced with C# 1.0 (with .NET 1.0) as a way to represent function pointers. Delegates like most other aspects of advanced C#/.NET programming were often misunderstood and a lot of times programmers didn't even know they were using them inside their code! One source of this problem was a rather cluggy syntax provided with the original C# 1.0 syntax. Luckily as .NET evolved, so did the syntax for delegates by becoming more concise and clear. This is exactly what this article focuses on; this is NOT an intro into delegates, how they relate/work with events or a "best practice" guide.
The best way to show delegate syntax in action is to try to solve a simple coding problem with them. Suppose I get asked this on an interview: I have a form with 2 text boxes and I can input 2 numbers. What I would like to do is when I click the "=" button (equals) is have the numbers be added via a delegate binary operation, by adding the two numbers.

So the form looks something like this:

Let's assume that we have an event handler already hooked up to the button and after we click that button we expect the two numbers to be added.

.NET 1.x (1.0 - 1.1) Solution (C# 1.0)

This solution has four parts:

Declare the delegate with the desired signature
Declare a method that matches the delegate signature
Instantiate the delegate (tell the delegate with method to call)
Call the delegate and retrieve the result

Delcare the delegate:

delegate int Add(int firstNumber, int secondNumber);

The delegate type is created by using the delegate keyword (much the same way we would declare a string type; i.e., string someString = "test";) The second word is the return type for our delegate. Since we are trying to add two numbers we expect to get a integer (int) back. Next, is the name of the delegate. In our case, we named the delegate Add (much the same way you would name a method). Lastly, we need want our code to add two numbers together. Therefore, we would like to have two interger parameters that are going to be passed from our text box.
In the code above, what we did was create a template in a sense of how we want our method to look like. We do not know what this method will do yet, but we do know it will have two integers as parameters and it will return an integer.

Declare a method that matches the delegate signature:

private int AddNumbers(int firstNumber, int secondNumber)
        {
            return firstNumber + secondNumber;
        }

Here we declared a method that matches the desired signature of our delegate type. Our method is called AddNumbers and it takes two integer parameters and has a integer return. The method is where our simple business logic of adding two numbers will occur and the method body will execute and give the delegate some kind of functionality (in our case add two numbers).

Instantiate the delegate (tell the delegate with method to call)

Add add = new Add(this.AddNumbers);

This piece of code will instantiate a new Add type and tell it to call the AddNumbers method. Behind the scenes, the compiler compiles the delegate type we declared (code in "Declare the delegate") into a class. This class can take a parameter for its constructor a method that matches the signature of the delegate. It doesn't matter what the method is called or what the underlying business logic does. The only thing that matters is that the signature of the method matches the signature of the delegate. To reiterate (in our case) this is a method that has 2 integer parameters with an integer return type.

Call the delegate and retrieve the result

int result = add(Convert.ToInt32(this.txtFirst.Text),Convert.ToInt32(this.txtSecond.Text));

Calling the delegate is the simplest part. Now that we have an instance of the delegate called "add", we simply pass in the two integer parameters. Above, we have two text boxes and we convert each Text property into an integer and pass them into the instance of our Add delegate "add". The delegate takes these parameters and simply calls the method it was told to in the step above and passes these paramters.
For those confused, you can just call the delegate directly. For example:

int result = add(3, 4);

As you will see below, all of the different types of using delegate code use the same way to call the delegate. This part of calling the delegate does not change, no matter what method you use!

Summary

Using delegates in .NET 1.0 - 1.1 (2002 - 2003) was not the friendliest. There were a few steps to go through. Many programmers taking the leap from VB.NET or another language simply by passed delegates because of the additional syntax. Imagine learning a new language and trying to conceptualize using delegates and their uses. Delegates in these early days of .NET were usually used/abused by C++ programmers familiar with the delegate C++ counterpart. Delegates also in those days had some performance issues; design implications (making a public delegate is bad) and some designs could cause memory problems.
Putting it all together would look something like this:

    1         // 1) Declare a delegate
    2         delegate int Add(int firstNumber, int secondNumber);
    3 
    4         // 2) Declare a method (matches the delegate signature)
    5         private int AddNumbers(int firstNumber, int secondNumber)
    6         {
    7             return firstNumber + secondNumber;
    8         }
    9 
   10         private void btnAdd_Click(object sender, EventArgs e)
   11         {
   12             // 3) Initialize the delegate to a method that matches the signature
   13             Add add = new Add(this.AddNumbers);
   14 
   15             // 4) retrieve the result
   16             int result = add(Convert.ToInt32(this.txtFirst.Text),Convert.ToInt32(this.txtSecond.Text));

Not counting comments/whitespace it was about 7 lines of code to declare/initialize/call a delegate back in the .NET 1.x days. More importantly, you have 4 seperate parts to this solution.

.NET 2.0 - 3.0 Solution (C# 2.0)

.NET 2.0 introduced a concept called anonymous methods. This allowed us to call inline business logic (i.e., a method) without having to have the method defined. The business logic simply became part of the delegate. Let's see how this improved our delegate syntax for our scenario.
This solution has three parts:

Declare the delegate with the desired signature
Instantiate the delegate (with the business logic defined inside the delegate "body")
Call the delegate and retrieve the result

Delcare the delegate:

delegate int Add(int firstNumber, int secondNumber);

The delegate type declaration is the same as the prior version.

Instantiate the delegate (with the business logic defined inside the delegate "body")

Add add = delegate(int firstNumber, int secondNumber)
        {
            return firstNumber + secondNumber;
        };

We put the business logic now inside the "body" of the instantiation of the delegate. Notice how we skipped the method decleration in this solution, because it's not needed since it's inside the delegate "body".
So, this is nice and clear and we eliminated a whole part (no more method to declare) and one statement of code. This is what anonymous methods allow us to do, by putting the method logic directly inside the "body" of the delegate. The syntax for the anonymous method starts with the word delegate itself after the equal sign. In this case, it tells the compiler that we are declaring an anonymous method. The next step is to define the parameters to match the signature of our Add method, which are the two intergers respectively. Our inline body of our delegate is the same as our AddNumbers method returning an integer. That's all there is to it. Anonymous methods can have no parameters and as well can have no (void) returns.

Call the delegate and retrieve the result

int result = add(Convert.ToInt32(this.txtFirst.Text),Convert.ToInt32(this.txtSecond.Text));

Same as before. Nothing new to see here.

Summary

Using delegates in .NET 2.0 - 3.0 became simpler. Not just because you eliminated one line of code, but because now it had one less "working part" and programmers not familiar with delegate syntax could easily tell what was going on. This solution obviously would not work when you wanted to design more complex/re-usable objects. However, it made the use of anonymous methods in predicates and simple situations much easier and the delegate syntax was finally resembling some brevity that functional languages enjoy.
In summary, our .NET 2.0 - 3.0 solution looks like this:

    1         // 1) Declare a delegate
    2         delegate int Add(int firstNumber, int secondNumber);
    3 
    4         // 2) Initialize the delegate using an anonymous method(new in .NET 2.0)
    5         Add add = delegate(int firstNumber, int secondNumber)
    6         {
    7             return firstNumber + secondNumber;
    8         };
    9 
   10         private void btnAdd_Click(object sender, EventArgs e)
   11         {
   12             // 3) Retrieve the result
   13             int result = add(Convert.ToInt32(this.txtFirst.Text),Convert.ToInt32(this.txtSecond.Text));

A lot more concise and we elminated 3 lines of code; 1 part (method decleration) and the code is a little clearer to read.

.NET 3.5 Solution (Type 1) (C# 3.0)

.NET 3.5 (C# 3.0) introduces even more brevity to delegate syntax with lambda expressions. Lambda expressions are a further evolution of syntax brevity for anonymous methods. You take the spirit of declaring the business logic inline with delegates even further. I broke the .NET 3.5 solution into type 1 and type 2. Type 1 uses just uses the new lambda expression syntax.
This solution has several parts:

Declare the delegate with the desired signature
Instantiate the delegate (with the business logic defined inside the delegate "body")
Call the delegate and retrieve the result

Delcare the delegate:

delegate int Add(int firstNumber, int secondNumber);

The delegate type declaration is the same as the prior version(s).

Instantiate the delegate (with the business logic defined inside the delegate "body")

Add add = (firstNumber, secondNumber) => firstNumber + secondNumber;

Whoa! That looks different. Let's take a step back and see how we got to the lambda expression from the anonymous method.
In the .NET 2.0 version we had something like this:

Add add = delegate(int firstNumber, int secondNumber)
        {
            return firstNumber + secondNumber;
        };

First, let's remove the delegate keyword. Since the delegate keyword back in the .NET 2.0 (C# 2) version told the compiler we were declaring an anonymous method, it needs to be replaced since we want to use lamdba expressions. Since we are going to replace the anonymous method syntax with lambda expression syntax, we need to use the keyword that tells the compiler we are working a lambda expression. This keyword is "=>". The compiler would like to see this after the parameters are defined but before the inline body of the expression.
Our first step in our lambda expression will look like this (This is valid syntax and will compile):

Add add = (int firstNumber, int secondNumber) =>
        {
            return firstNumber + secondNumber;
        };

The expression now reads: The parameters of integer firstNumber and integer secondNumber "goes to" return the sum of firstNumber plus secondNumber. The code above is now a fully functioning Lamdba Expression and not an anonymous method anymore. Replacing the "delegate" keyword with the appropriate location for the "=>" keyword converted this from an anonymous method to a lambda expression. This is very important, so the compiler with this simple keyword swap now knows we are dealing with a lambda expression.
We didn't really gain much here. We essentially replaced one keyword with another. What we can do next is add additional lambda expression shortcuts. Lambda expressions do not require curly braces or return type.
If we remove both of these, this expression now becomes:

Add add = (int firstNumber, int secondNumber) => firstNumber + secondNumber;

That's getting much better. Notice, no curly braces or the return keyword; the C# 3.0 compiler can derive all this information for us! The expression looks more concise now. But we can do better. The compiler is even smarter now since it can detect the type of parameters we want to use. We don't need to explicitly say that we are passing in two integers; this is detected by the compiler.
Now the full expression (after removing the two int keywords) remains as just the parameter names:

Add add = (firstNumber, secondNumber) => firstNumber + secondNumber;

Call the delegate and retrieve the result

int result = add(Convert.ToInt32(this.txtFirst.Text),Convert.ToInt32(this.txtSecond.Text));

Same as before. Nothing new to see here.

Summary

We did a lot here. Lambda expressions make a big difference in syntax brevity and clarity. Let's take look what we have now:

    1         // 1) Declare a delegate
    2         delegate int Add(int firstNumber, int secondNumber);
    3 
    4         // 2) Initialize the delegate using a lambda expressions (new in .NET 3.5)
    5         Add add = (firstNumber, secondNumber) => firstNumber + secondNumber;
    6 
    7         private void btnAdd_Click(object sender, EventArgs e)
    8         {
    9             // 3) Retrieve the result
   10             int result = add(Convert.ToInt32(this.txtFirst.Text),Convert.ToInt32(this.txtSecond.Text));

A lot more concise and we elminated 3 more lines of code! Now we are getting somewhere.

.NET 3.5 Solution (Type 2) (C# 3.0)

The type 2 solutions still utilizes lamdba expressions. However, it also uses the new Func delegate. A Func is a delegate type with several generic parameters defined. There are 5 different Func delegates pre-defined for you with .NET 3.5. Why are there 5 different ones? This should cover you for most of your scenarios when designing methods/delegates, etc. Usually if you are creating signatures of methods with more than 4 parameters, you probably need to refactor your parameters into an object. '
For example, the Func that we need has to have 2 input parameters and a return parameter. This one that is pre-defined in .NET will suit us great:

public delegate TResult Func<T1, T2, TResult>(T1 arg1, T2 arg2);

This solution has ONLY TWO parts:

Declare & instantiate the delegate (with the business logic defined inside the delegate "body")
Call the delegate and retrieve the result

Declare & instantiate the delegate (with the business logic defined inside the delegate "body")

We already have a delegate (Func) with the required signature we need. It is a generic delegate; however, we can determine the types of parameters/result we need. All we need to do is create a variable of this type and pass in the expression we created above (.NET 3.5 Type 1). Our entire decleration/instatiation is in ONE line of code now:

Func<int, int, int> add = (firstNumber, secondNumber) => firstNumber + secondNumber;

Now that's nice concise syntax!. All we did was declare a variable called add of type Func with 2 integer parameters and an integer return parameter (return type). On the right-hand side of the equation we simply just use the lamdba expression from the example above.

Call the delegate and retrieve the result

int result = add(Convert.ToInt32(this.txtFirst.Text),Convert.ToInt32(this.txtSecond.Text));

Same as before. Nothing new to see here.

Summary

This is as simple as you are going to get right now; a single line of code to declare/initialize a delegate with a lambda expression.

    1         Func<int, int, int> add = (firstNumber, secondNumber) => firstNumber + secondNumber;
    2 
    3         private void btnAdd_Click(object sender, EventArgs e)
    4         {
    5             // 2) Retrieve the result
    6             int result = add(Convert.ToInt32(this.txtFirst.Text),Convert.ToInt32(this.txtSecond.Text));

This is as concise as you will get. One line of code to rule them all :)
If you want to delve deeper, I would suggest picking up a C# 3 book. I didn't really explain some of the origins of this code and some of the nuances with anonymous methods/lambda expressions or even delegates. I just wanted to focus on the evolution of the C# syntax. Attached is a simple VS 2008 solution zip that demonstrates the 4 different major -- there are lot more smaller permutations -- ways to write delegate syntax. I broke the solution so that each type of code is in its own respective form (this way, every variable is named the same). I also did not want to introduce any other C# constructs but wanted to strictly focus on the topic which was the syntax.
EvolutionOfDelegates.zip (55.06 kb)

What is Software Apprenticeship??

2011-06-14T01:28:00.000-07:00

Electrical Apprenticeship

Pilot Apprenticeship

Mechanical Apprenticeship

Karate Apprenticeship

Kung Fu Apprenticeship

But……………………………………………

Software Apprenticeship