2. Why we need Programing
Techniques ?
Programing technique is about generalizing software
components so that they can be easily reused in a wide
variety of situations. Programming techniques include :
1) Complexity factor
2) Using bitwise operators
3) Iteration vs Recursions
4) Implementing design patterns
3. Lets starts with Arrays
• An array is a collection of variables where each variable
has the same data type.
• Each variable in an array is called an element and has an
index, also called the subscript, which denotes that
element’s location within the array.
• One advantage of using arrays is that all the elements
within an array can be declared, created, and passed to a
function as a whole.
• Arrays are of two types fixed memory allocation (fixed
length) or array list (unlimted size).
4. Complexity Factor : Lets
starts with Arrays
• How to reverse an Array.
• First Method used an Inbuilt method. (EASY)
• Iterate from last index of array to index 0 and put all
elements in new array. here it loops for n times, where n
is number of items in an array.
• One way to reverse the elements in an array is to use two
index variables: one index starts at the beginning of the
array, and the other starts at the end of the array. Then
write a loop that repeats n / 2 times where n is the number
of elements in the array.
5. Complexity Factor : Lets
starts with Arrays
public static void reverse( float[] list) {
int left = 0;
int right = list.length - 1;
while (left < right) {
// Exchange two elements.
float swap = list[ left];
list[ left] = list[ right];
list[ right] = swap;
// Move the indices toward the center.
left + +;
right--;
}
}
6. Bit Operators
• A boolean variable, named after the British mathematician George Boole, is a variable that holds either false or true and
nothing else.
• An efficient way to store many boolean variables is in a group called a bitset where each boolean variable is stored in a
single bit with 0 meaning false and 1 meaning true.
• One important operation that must be performed on a bitset is to count how many bits are set, which is sometimes called the
population count.
• A bitwise operation is a manipulation of one or two binary numbers to produce another binary number.
• There are seven standard bitwise operations that a computer can perform: left shift unsigned right shift signed right shift not
and or exclusive or
• left shift (<<)
• unsigned left shift (>>>)
• signed right shift (>>)
• not (! or ~)
• and (&)
• or (||)
• exclusive or
7. Bit Operators
• The left shift operator is two less than symbols (< <) and shifts all the bits in an integer to the left by a specified
number of locations, filling the right-most bits with 0 and losing the values in the left-most bits.
• e.g : x = 58 ; x << 2 = 232 // 58 * 4 = 232 , x*2^n
58 0000 0000 0000 0000 0000 0000 0011 1010
232 0000 0000 0000 0000 0000 0000 1110 1000
• The unsigned right shift operator (also called the logical right shift operator ) is three greater than symbols (> >
>) and shifts all the bits in an integer to the right by a specified number of locations, filling the left-most bits with 0
and losing the values in the right-most bits.
• e.g : x = 58 ; x >>> 2 = 14 // 58 / 4 = 14 , x/2^n
58 0000 0000 0000 0000 0000 0000 0011 1010
14 0000 0000 0000 0000 0000 0000 0000 1110
• In a two’s complement integer, the left-most bit is the sign bit and contains a 0 if the integer is non-negative and
contains a 1 if the integer is negative. The signed right shift operator (also called the arithmetic right shift
operator). Example same as above.
• The bitwise not operator is the tilde (~) and takes an integer as input and clears every set bit and sets every
clear bit, or in other words, switches every 1 bit to 0 and every 0 bit to 1.
8. Bit Operators
• The bitwise and operator is the ampersand (&) and takes two integers as input and produces an
integer with bits set where the bits are set in both inputs and clear everywhere else. This is the same
operation as logical and but performed on each bit. Within a program, bitwise and is often used to
test if a bit is set and to clear bits in a variable.
• The bitwise or operator is the vertical bar (|) and takes two integers as input and produces an
integer with bits set where the bits are set in either or both inputs and clear everywhere else. This is
the same operation as logical or but performed on each bit. Within a program, bitwise or is often used
to set bits in a variable.
• The bitwise exclusive or operator is the caret ( ^) and takes two integers as input and produces an
integer with bits set where the bits in the two inputs are different and clear everywhere else. This is the
same operation as logical exclusive or but performed on each bit . Within a program, bitwise
exclusive or is often used in data encryption and can even be used to swap the values of two
variables.
• All the bitwise operators , except not (~), can be combined with the assignment operator (=) to make
shortcut operators. e.g. x <<=2, x &=0x0f
9. Bit Operators
write code to count the number of bits set to 1 in a 64-bit number. This is sometimes called the population count.
/** Returns the number of bits set in a 64-bit word. */ e.g 0x00 00 00 04 a0 3f 6e 8c.
public static int nbits( long word) {
int n = 0;
for (int i = 0; i != 64; + + i) {
if (( word & 1) != 0) {
+ + n;
}
word > > > = 1;}
return n;}
// More Faster way
public static int nbits( long word) {
int n = 0;
while (word != 0) {
if (( word & 1) != 0) {
+ + n; }
word > > > = 1; }
return n; }
10. Bit Operators
Addition Instead of If
Computers often execute if statements slowly because modern CPUs have a pipeline of instructions that
are in the process of being decoded and executed. When the CPU begins executing an if-else statement,
before it knows the value of the condition (true or false), it will predict that value (usually as true) and
begin speculatively executing the statements in the corresponding part of the if-else statement. However,
when the CPU finishes calculating the value of the condition, if it has predicted incorrectly, it must unload
the instruction pipeline and begin executing the statements in the other part of the if-else statement which
takes time. When an if statement does not have a matching else, the CPU must still predict whether the
condition is true or false and speculatively execute statements according to its prediction.
/** Returns the number of bits set in a 64-bit word. */
public static int nbits( long word) {
int n = 0;
while (word != 0) {
n + = (int) word & 1;
word > > > = 1;
}
return n;
}
11. Iteration and Recursion
• Iteration is the process of repeating a block of statements in a computer program by using a repetition control structure,
also known as a loop. Here is a simple example of iteration written in Java that computes n factorial (n!).
• Recursion is the process of repeating a block of statements in a computer program by using a recursive function. A
recursive function is a function that calls itself either directly or indirectly. A function F calls itself indirectly by calling
function G which calls function F. A recursive algorithm solves a problem by repeatedly dividing it into smaller sub-
problems until reaching the simpliest sub -problem and then solves that simpliest problem. All recursive algorithms must
have three parts:
• A base case which is the simpliest sub-problem and when the recursion will stop
• Code to work toward the base case by dividing the problem into sub-problems
• One or more recursive function calls
/** Recursively computes n factorial (n!) * which is n * (n-1) * (n-2) * ... 1 */
public static long factorial( int n) {
if (n > 1) {
return n * factorial( n - 1);
}
return 1;
}
12. Iteration and Recursion
• Recursion began to make sense to me when I learned that
• Recursion comes to computer science from mathematics, and mathematicians
define some mathematical functions, such as the Fibonacci series, in a recursive
form.
• Some programming languages such as Erlang, ProLog, and Haskell, don’t
include iteration, because the inventors of those languages believed that
iteration was error prone and that recursive solutions revealed the intrinsic
structure of a problem.
• There are many programming problems more complex than the simple recursive
examples shown in text books (such as n factorial) that are elegantly solved
using recursion.
13. Iteration and Recursion
• Advantages of Recursion
• If a computing problem can be broken into smaller self-similar problems, a recursive solution is almost
always shorter and more elegant than an iterative solution.
• A recursive function uses existing, well-understood, and tested functionality, namely the system stack, as
part of its solution instead of requiring that another stack module be written.
• It is sometimes necessary to prove that a computing solution is correct. Proving correctness is easier for a
recursive solution than an iterative solution because recursion and proof by induction are closely related.
• Disadvantages
• Using recursion means many function calls. In many programming languages, a function call is relatively
slow compared to other operations. In languages that don’t include iteration, the language compiler or
interpreter will transform some recursive functions into iterative ones to lower the number of function calls.
If a programmer writes a recursive function in a language that doesn’t include this optimization, that
function will likely be much slower than an iterative function that solves the same problem.
• Recursion can be hard to learn and understand especially for someone that has already learned iteration.
• A recursive function may use all the memory in the system stack which will cause the program to crash.
14. Design Pattern
In software engineering, a design pattern is a general reusable solution to a commonly occurring problem
within a given context in software design. A design pattern is not a finished design that can be transformed
directly into source or machine code. It is a description or template for how to solve a problem that can be
used in many different situations. Patterns are formalized best practices that the programmer can use to solve
common problems when designing an application or system.
• Design patterns can speed up the development process by providing tested, proven development
paradigms. Effective software design requires considering issues that may not become visible until later in
the implementation. Reusing design patterns helps to prevent subtle issues that can cause major
problems[citation needed], and it also improves code readability for coders and architects who are familiar
with the patterns.
• By definition, a pattern must be programmed anew into each application that uses it. Since some authors
see this as a step backward from software reuse as provided by components, researchers have worked to
turn patterns into components.
• Design patterns were originally grouped into the categories: creational patterns, structural patterns, and
behavioral patterns, and described using the concepts of delegation, aggregation, and consultation. For
further background on object-oriented design, see coupling and cohesion, inheritance, interface, and
polymorphism. Another classification has also introduced the notion of architectural design pattern that may
be applied at the architecture level of the software such as the Model–View–Controller pattern.
15. Design Pattern
Creational Pattern
• Abstract Factory :
Provide an interface for creating families of related or dependent objects
without specifying their concrete classes.
• Builder
Separate the construction of a complex object from its representation,
allowing the same construction process to create various representations.
• Factory method
Define an interface for creating a single object, but let subclasses decide
which class to instantiate. Factory Method lets a class defer instantiation to
subclasses (dependency injection).
• Prototype
Specify the kinds of objects to create using a prototypical instance, and
create new objects by copying this prototype.
• Singleton
Ensure a class has only one instance, and provide a global point of access
to it.
16. Design Pattern
Structural patterns
• Adapter or Wrapper or Translator.
Convert the interface of a class into another interface clients expect. An adapter lets
classes work together that could not otherwise because of incompatible interfaces. The
enterprise integration pattern equivalent is the translator.
• Composite
Compose objects into tree structures to represent part-whole hierarchies. Composite lets
clients treat individual objects and compositions of objects uniformly.
• Decorator
Attach additional responsibilities to an object dynamically keeping the same interface.
Decorators provide a flexible alternative to subclassing for extending functionality.
• Facade
Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-
level interface that makes the subsystem easier to use.
• Module
Group several related elements, such as classes, singletons, methods, globally used, into
a single conceptual entity.
• Front Controller
The pattern relates to the design of Web applications. It provides a centralized entry point
for handling requests.
17. Design Pattern
Behavioral patterns
• Blackboard
Generalized observer, which allows multiple readers and writers. Communicates
information system-wide.
• Interpreter
Given a language, define a representation for its grammar along with an interpreter that
uses the representation to interpret sentences in the language.
• Iterator
Provide a way to access the elements of an aggregate object sequentially without
exposing its underlying representation.
• Null object
Avoid null references by providing a default object.
• Strategy
Define a family of algorithms, encapsulate each one, and make them interchangeable.
Strategy lets the algorithm vary independently from clients that use it.
• Template method
Define the skeleton of an algorithm in an operation, deferring some steps to
subclasses. Template method lets subclasses redefine certain steps of an algorithm
without changing the algorithm's structure.
• State
Allow an object to alter its behavior when its internal state changes. The object will
appear to change its class.
18. Design Pattern
Concurrency patterns
• Active Object
Decouples method execution from method invocation that reside in their own thread of
control. The goal is to introduce concurrency, by using asynchronous method invocation
and a scheduler for handling requests.
• Balking
Only execute an action on an object when the object is in a particular state.
• Messaging design pattern (MDP)
Allows the interchange of information (i.e. messages) between components and
applications.
• Monitor object
An object whose methods are subject to mutual exclusion, thus preventing multiple
objects from erroneously trying to use it at the same time.
• Event-based asynchronous
Addresses problems with the asynchronous pattern that occur in multithreaded
programs.
• Join
Join-patterns provides a way to write concurrent, parallel and distributed programs by
message passing. Compared to the use of threads and locks, this is a high level
programming model.
• Lock
One thread puts a "lock" on a resource, preventing other threads from accessing or
modifying it.
19. Last But Not Least
Characteristics of a bad Programmer
• The StackOverflow bot
• The I-am-not-a-tester
• The I-hate-documentation
• The ugly: My code works, but:
• Have variables named x, flag, str, arr, etc.
• -Most of what I write is in one giant method.
• -There is no indentation.
• -No consistent coding convention or style.
• -Global variables spewed all over the place, etc.
• The short-term investor
• He codes. He deploys. He moves on. No attempt to learn the problem. No interest in the domain.
Just give this guy a piece of code, he will slog on it overnight and hand it over.
• The protester
• “I didn’t do this”.
• “This looks bad”.
• “Not my problem”.
• “This isn’t related really to my fix, but someone way over there made a mistake”.
• “I hate this (loop this sentence 10 times a day)”.
• “I can’t fix this, get the person who made this code to fix it”.
• The dictator : My way or the highway
• The overcautious
• The careless
• Forgets to take a backup, snapshots, has multiple working directories of code.
• The lazy pseudo-hacker
• Just Use tricks to make it work for now.
