# Programmers Need to Solve Uncertain Problems

1- Opening - Programmers need to solve uncertain problems

uncertain problems.Review of the first issue
Records of previous discussion topics: records of each discussion topic

the second term
uncertain problems.DIY class: First, Deeply Inspire Yourself deeply inspire yourself
Second, Do It Yourself brings out true knowledge
I always heard about Ali and so -and-so. I heard about Mr. Gujing , and he often pondered his development specifications. Some of them didn’t understand at first glance, but when they went deeper, they realized the greatness. Last year, I heard that there was a DIY class, but it has already ended. Fortunately, my classmates and other friends learned a little indirectly. This year, I finally have the opportunity to communicate with Teacher Guzhen systematically . I am very lucky, so I want to try hard. I also know that the rules and time are harsh, but I really want to I'm just a superficial code farmer. I can only investigate simple problems. They all say that martial arts techniques are inseparable from the same sect. I want to find this sect, and I want to internalize it in my heart, so my purpose is to learn , I want to know more excellent you, so everything else is secondary, thank you teacher Lonely
uncertain problems.After hearing about the rules, I sometimes feel unsatisfactory, but with such a good opportunity to get in touch with the big guys, once there is a joy. Therefore, I will try to be the class committee first and try my best to take on more responsibilities. Secondly, I want to summarize and form a blog, and understand every sharing.

Quick row
lonely teacher tested himself in the fastest few minutes to complete the quick row, and passed the test directly, in 3 minutes.
Teacher Gujin added a note, which is an appetizer for everyone
/**
* Quick sort
*
* @param source sorted array
* @param left The leftmost subscript of the closed interval after the array is partitioned
* @param right The rightmost subscript of the closed interval after the array is partitioned
*/
public static void quickSort ( int[ ] source, int left, int right) {
// Exit condition for recursion. Array subscript left must be greater than or equal to right. The array is empty or has only one element, return directly
if (source == null || left >= right) {
return;
}

// Set the leftmost array element as the reference value, the array smaller than the pivot is placed on the left, and the array larger than the pivot is placed on the right
int pivot = source[left];
// Define two pointers, pointing to the leftmost and the rightmost, respectively, moving in the middle direction
int pointerLeft = left;
int pointerRight = right;
while ( pointerLeft < pointerRight ) {
// If pointerRight moves to the left, a value larger than pivot is encountered
while ( pointerLeft < pointerRight && source[ pointerRight ] >= pivot) {
// move the right pointer to the left
pointerRight --;
}
// Swap it, don't be afraid, the value on the left is pivot, the next loop must be able to move the pointer further to the right
swapValue ( source, pointerLeft , pointerRight );

// If pointerLeft moves to the right, a value smaller than pivot is encountered
while ( pointerLeft < pointerRight && source[ pointerLeft ] <= pivot) {
// move the left pointer to the right
pointerLeft ++;
}
swapValue ( source, pointerLeft , pointerRight );
}

// The left and right of the parameters exist as boundaries, which are finally used here
quickSort ( source, left, pointerLeft - 1);
quickSort ( source, pointerLeft + 1, right);
}

private static void swapValue ( int[ ] source, int pointerLeft , int pointerRight ) {
// If the pointers have already overlapped when swapping, then there is no need to swap again
if ( pointerLeft >= pointerRight ) {
return;
}

int t = source[ pointerLeft ];
source[ pointerLeft ] = source[ pointerRight ];
source[ pointerRight ] = t;
}
}

Gold Nine and Silver Ten: Interview tips for Java developers
Gold Nine Silver Ten: How to interview big factories for Java developers-Let's start the class

the deepest
Architecture is a competency, not a position
premise:
architecture to
The transformation of architectural advancement into technological advancement

## uncertain problems.The architecture is evolving

1.Knowledge of Design Patterns
2.Knowledge of architecture itself? the purpose of the architecture,
3.Architecture Methodology
The problem to be solved by the architecture:
1.Determine where the boundaries of your system are?
2.What are the principles that guide the evolution of design
3.Identify non-functional requirements
Liskov Substitution Principle ( LSP) is one of the basic principles of object-oriented design. The Liskov Substitution Principle states that wherever a base class can appear, a subclass must appear.
Example: "Put down the weapon and surrender immediately" in the police and bandit movie, the weapon is abstract, corresponding to the specific pistol, bayonet, etc. in the hands of the bandit
Converting a deterministic description into code is not difficult
But, throughout the tech world, there are questions of uncertainty. It is precisely because we need to solve uncertain problems that we need to use the programmer's IQ to iterate.