+
+$ kubectl get nodes
+NAME STATUS ROLES AGE VERSION
+minikube Ready master 88s v1.17.3
+```
+
+#### Kubernetes Jobs
+
+Just like anything else in the Kubernetes world, you can create Kubernetes Jobs with a definition file. Create a file called `sample-jobs.yaml` using your favorite editor.
+
+Here is a snippet of the file that you can use to create an example Kubernetes Job:
+
+
+```
+apiVersion: batch/v1 ## The version of the Kubernetes API
+kind: Job ## The type of object for jobs
+metadata:
+ name: job-test
+spec: ## What state you desire for the object
+ template:
+ metadata:
+ name: job-test
+ spec:
+ containers:
+ - name: job
+ image: busybox ## Image used
+ command: ["echo", "job-test"] ## Command used to create logs for verification later
+ restartPolicy: OnFailure ## Restart Policy in case container failed
+```
+
+Next, apply the Jobs in the cluster:
+
+
+```
+`$ kubectl apply -f sample-jobs.yaml`
+```
+
+Wait a few minutes for the pods to be created. You can view the pod creation's status:
+
+
+```
+`$ kubectl get pod –watch`
+```
+
+After a few seconds, you should see your pod created successfully:
+
+
+```
+$ kubectl get pods
+ NAME READY STATUS RESTARTS AGE
+ job-test 0/1 Completed 0 11s
+```
+
+Once the pods are created, verify the Job's logs:
+
+
+```
+`$ kubectl logs job-test job-test`
+```
+
+You have created your first Kubernetes Job, and you can explore details about it:
+
+
+```
+`$ kubectl describe job job-test`
+```
+
+Clean up the Jobs:
+
+
+```
+`$ kubectl delete jobs job-test`
+```
+
+#### Kubernetes CronJobs
+
+You can use CronJobs for cluster tasks that need to be executed on a predefined schedule. As the [documentation explains][8], they are useful for periodic and recurring tasks, like running backups, sending emails, or scheduling individual tasks for a specific time, such as when your cluster is likely to be idle.
+
+As with Jobs, you can create CronJobs via a definition file. Following is a snippet of the CronJob file `cron-test.yaml`. Use this file to create an example CronJob:
+
+
+```
+apiVersion: batch/v1beta1 ## The version of the Kubernetes API
+kind: CronJob ## The type of object for Cron jobs
+metadata:
+ name: cron-test
+spec:
+ schedule: "*/1 * * * *" ## Defined schedule using the *nix style cron syntax
+ jobTemplate:
+ spec:
+ template:
+ spec:
+ containers:
+ - name: cron-test
+ image: busybox ## Image used
+ args:
+ - /bin/sh
+ - -c
+ - date; echo Hello this is Cron test
+ restartPolicy: OnFailure ## Restart Policy in case container failed
+```
+
+Apply the CronJob to your cluster:
+
+
+```
+$ kubectl apply -f cron-test.yaml
+ cronjob.batch/cron-test created
+```
+
+Verify that the CronJob was created with the schedule in the definition file:
+
+
+```
+$ kubectl get cronjob cron-test
+ NAME SCHEDULE SUSPEND ACTIVE LAST SCHEDULE AGE
+ cron-test */1 * * * * False 0 <none> 10s
+```
+
+After a few seconds, you can find the pods that the last scheduled job created and view the standard output of one of the pods:
+
+
+```
+$ kubectl logs cron-test-1604870760
+ Sun Nov 8 21:26:09 UTC 2020
+ Hello from the Kubernetes cluster
+```
+
+You have created a Kubernetes CronJob that creates an object once per execution based on the schedule `schedule: "*/1 * * * *"`. Sometimes the creation can be missed because of environmental issues in the cluster. Therefore, they need to be [idempotent][9].
+
+### Other things to know
+
+Unlike deployments and services in Kubernetes, you can't change the same Job configuration file and reapply it at once. When you make changes in the Job configuration file, you must delete the previous Job from the cluster before you apply it.
+
+Generally, creating a Job creates a single pod and performs the given task, as in the example above. But by using completions and [parallelism][10], you can initiate several pods, one after the other.
+
+### Use your Jobs
+
+You can use Kubernetes Jobs and CronJobs to manage your containerized applications. Jobs are important in Kubernetes application deployment patterns where you need a communication mechanism along with interactions between pods and the platforms. This may include cases where an application needs a "controller" or a "watcher" to complete tasks or needs to be scheduled to run periodically.
+
+--------------------------------------------------------------------------------
+
+via: https://opensource.com/article/20/11/kubernetes-jobs-cronjobs
+
+作者：[Mike Calizo][a]
+选题：[lujun9972][b]
+译者：[译者ID](https://github.com/译者ID)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://opensource.com/users/mcalizo
+[b]: https://github.com/lujun9972
+[1]: https://opensource.com/sites/default/files/styles/image-full-size/public/lead-images/kubernetes_containers_ship_lead.png?itok=9EUnSwci (Ships at sea on the web)
+[2]: https://kubernetes.io/
+[3]: https://kubernetes.io/docs/concepts/workloads/controllers/job/
+[4]: https://kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/
+[5]: https://phoenixnap.com/kb/how-to-install-kubernetes-on-centos
+[6]: https://minikube.sigs.k8s.io/docs/start/
+[7]: https://kubernetes.io/docs/reference/kubectl/kubectl/
+[8]: https://v1-18.docs.kubernetes.io/docs/concepts/workloads/controllers/cron-jobs/
+[9]: https://en.wikipedia.org/wiki/Idempotence
+[10]: https://kubernetes.io/docs/concepts/workloads/controllers/job/#parallel-jobs
diff --git a/sources/tech/20201123 Day 11- learning about learning rates.md b/sources/tech/20201123 Day 11- learning about learning rates.md
new file mode 100644
index 0000000000..12be99f3be
--- /dev/null
+++ b/sources/tech/20201123 Day 11- learning about learning rates.md
@@ -0,0 +1,105 @@
+[#]: collector: (lujun9972)
+[#]: translator: ( )
+[#]: reviewer: ( )
+[#]: publisher: ( )
+[#]: url: ( )
+[#]: subject: (Day 11: learning about learning rates)
+[#]: via: (https://jvns.ca/blog/2020/11/23/day-11--learning-about-learning-rates/)
+[#]: author: (Julia Evans https://jvns.ca/)
+
+Day 11: learning about learning rates
+======
+
+Hello!
+
+On Friday I trained an RNN to count to 3 (1 2 3 1 2 3 1 2 3), thanks to some great advice from another Recurser. I figured that once I got that working, I could then extend that and train the same RNN on a bunch of Shakespearean text to get it to generate vaguely Shakespeare-y text.
+
+But on Friday I couldn’t get that to work! I was puzzled by this, but today I figured out what was happening.
+
+### what’s a learning rate?
+
+First, here’s a very short “deep learning for math majors” explanation of how training for a deep learning model works in general. I wrote this to help consolidate my own understanding on Friday.
+
+ * The model takes the training data and weights and outputs a single number, the output of the loss function
+ * The model’s “weights” are the parameters of all the matrices in the model, like if there’s a 64 x 64 matrix then there are 4096 weights
+ * For optimization purposes, this function should be thought of as a function of the weights (not the training data), since the weights are going to change and the function isn’t
+ * Training is basically gradient descent. You take the derivative of the function (aka gradient), with respect to the weights of all the matrices/various functions in the model
+ * The way you take this derivative is using the chain rule, the algorithm for applying the chain rule to a neural network is called “backpropagation”
+ * Then you adjust the parameters by a multiple of the gradient (since this is gradient descent). The multiple of the gradient that you use is called the **learning rate** – it’s basically `parameters -= learning_rate * gradient`
+ * machine learning model training is a lot like general continuous function optimization in that finding the “right” step size to do gradient descent is basically impossible so there are a lot of heuristics for picking step learning rates that will work. One of these heuristics is called [Adam][1]
+
+
+
+### if you set your learning rate too high, the model won’t learn anything
+
+So back to our original problem: when I was training my model to generate Shakespeare, I noticed that my model wasn’t learning anything! By “not learning anything”, I mean that the value of the loss function was not going down over time.
+
+I eventually figured out that this was because my learning rate was too high! It was 0.01 or something, and changing it to more like 0.002 resulted in more learning progress. Hooray!
+
+I started to generate text like this:
+
+```
+erlon, w oller. is. d y ivell iver ave esiheres tligh? e ispeafeink
+teldenauke'envexes. h exinkes ror h. ser. sat ly. spon, exang oighis yn, y
+hire aning is's es itrt. for ineull ul'cl r er. s unt. y ch er e s out twiof
+uranter h measaker h exaw; speclare y towessithisil's aches? s es, tith s aat
+```
+
+which is a big improvement over what I had previously, which was:
+
+```
+kf ;o 'gen '9k ',nrhna 'v ;3; ;'rph 'g ;o kpr ;3;tavrnad 'ps ;]; ;];oraropr
+;9vnotararaelpot ;9vr ;9
+```
+
+But then training stalled again, and I felt like I could still do better.
+
+### resetting the state of the optimizer is VERY BAD
+
+It turned out that the reason training had stalled the second time was that my code looked like this:
+
+```
+for i in range(something):
+ optimizer = torch.optim.Adam(rnn.parameters())
+ ... do training things
+```
+
+I’d written the code this way because I didn’t realize that the state of the optimizer (“Adam”) was important, so I just reset it sometimes because it seemed convenient at the time.
+
+It turns out that the optimizer’s state is very important, I think because it slowly reduces the training rate as training progresses. So I reorganized my code so that I only initialized the optimizer once at the beginning of training.
+
+I also made sure that when I saved my model, I also saved the optimizer’s state:
+
+```
+torch.save({'model_state_dict': rnn.state_dict(), 'optimizer_dict': optimizer.state_dict()}, MODEL_PATH)
+```
+
+Here’s the “Shakespeare” the model was generating after I stopped resetting the optimizer all the time:
+
+```
+at soerin, I kanth as jow gill fimes, To metes think our wink we in fatching
+and, Drose, How the wit? our arpear War, our in wioken alous, To thigh dies wit
+stain! navinge a sput pie, thick done a my wiscian. Hark's king, and Evit night
+and find. Woman steed and oppet, I diplifire, and evole witk ud
+```
+
+It’s a big improvement! There are some actual English words in there! “Woman steed and oppet!”
+
+### that’s it for today!
+
+Tomorrow my goal is to learn what “BPTT” means and see if I can use it to train this model more quickly and maybe give it a bigger hidden state than 87 parameters. And once I’ve done that, maybe I can start to train more interesting models!!
+
+--------------------------------------------------------------------------------
+
+via: https://jvns.ca/blog/2020/11/23/day-11--learning-about-learning-rates/
+
+作者：[Julia Evans][a]
+选题：[lujun9972][b]
+译者：[译者ID](https://github.com/译者ID)
+校对：[校对者ID](https://github.com/校对者ID)
+
+本文由 [LCTT](https://github.com/LCTT/TranslateProject) 原创编译，[Linux中国](https://linux.cn/) 荣誉推出
+
+[a]: https://jvns.ca/
+[b]: https://github.com/lujun9972
+[1]: https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam
diff --git a/sources/tech/20201124 A beginner-s guide to developing with React.md b/sources/tech/20201124 A beginner-s guide to developing with React.md
new file mode 100644
index 0000000000..7928fb6b43
--- /dev/null
+++ b/sources/tech/20201124 A beginner-s guide to developing with React.md
@@ -0,0 +1,284 @@
+[#]: collector: (lujun9972)
+[#]: translator: ( )
+[#]: reviewer: ( )
+[#]: publisher: ( )
+[#]: url: ( )
+[#]: subject: (A beginner's guide to developing with React)
+[#]: via: (https://opensource.com/article/20/11/reactjs-tutorial)
+[#]: author: (Shedrack Akintayo https://opensource.com/users/shedrack-akintayo)
+
+A beginner's guide to developing with React
+======
+A step-by-step guide to using React in your web and mobile user
+interfaces.
+![Gears connecting][1]
+
+[React][2] is a JavaScript user interface (UI) library that was built and is maintained by Facebook. React helps JavaScript developers think logically and functionally about how they want to build a UI.
+
+With React, you can build:
+
+ 1. Single-page applications
+ 2. Applications that are easy to understand
+ 3. Scalable applications
+ 4. Cross-platform applications
+
+
+
+React allows developers to build applications declaratively and offers a unidirectional flow of data.
+
+### React's advantages
+
+The following features explain why React is one of the [most popular][3] web frameworks.
+
+ * **It is declarative:** React makes it extremely painless to build interactive user interfaces, design basic views for your application based on various states, and update and render new views when the data in your application changes.
+ * **It is component-based:** React gives you the ability to build encapsulated components that can manage their own state, then puts them together to build complex UIs. The logic of these components is written in JavaScript instead of templates, so you easily pass actual data and keep state out of the [document object model][4] (DOM).
+ * **You can learn once, write anywhere:** React gives you the ability to build for both mobile (React Native) and the web. There's no need to rewrite your existing codebase; you can just integrate React with your existing code.
+ * **The virtual DOM:** React introduced a wrapper around the regular DOM called the virtual DOM (VDOM). This allows React to render elements and update its state faster than the regular DOM.
+ * **Performance:** React has great performance benefits due to the VDOM and one-way flow of data.
+
+
+
+### The virtual DOM
+
+React's VDOM is like a virtual copy of the original DOM. It offers one-way data binding, which makes manipulating and updating the VDOM quicker than updating the original DOM. The VDOM can handle multiple operations in milliseconds without affecting the general page performance.
+
+This VDOM supports React's declarative API: You basically tell React what state you want the UI to be in, and it ensures that the DOM matches that state.
+
+### Prerequisites for learning React
+
+Learning React requires basic knowledge of JavaScript, HTML, and CSS. To use React's power effectively, it helps to be familiar with [ECMAScript 6][5] (ES6) and functional and object-oriented programming.
+
+You also need the following things installed on your computer:
+
+ * [NodeJS][6]
+ * [npm][7] (comes bundled with NodeJS)
+ * [Yarn][8] (an alternative to NPM)
+
+
+
+### Basic React concepts
+
+It also helps to have an understanding of React's concepts.
+
+#### Components
+
+Components are standalone, reusable pieces of code. They have the same purpose as JavaScript functions but work alone and return HTML via a built-in render function. They are two main types of components:
+
+ * **Class components** offer more control in the form of lifecycle hooks, managing and handling state, and API calls. For example: [code] class MyComponent extends React.Component {
+ render() {
+ return <div>This is a class component</div>;
+ }
+}
+```
+ * **Functional components** were used for rendering just views without any form of state management or data request until [React Hooks][9] was introduced. For example: [code] Function myComponent() {
+ return (
+ <div>A functional Component</div>
+ )
+ }
+```
+
+
+
+#### Props
+
+React props are like function arguments in JavaScript and attributes in HTML. They are read-only. For example:
+
+
+```
+function Welcome(props) {
+ return <h1>Hello, {props.name}</h1>;
+}
+```
+
+#### State
+
+React components have a built-in object called _state_, which is where you store property values that belong to a particular component. If a component's state changes at any point in time, the component re-renders. For example:
+
+
+```
+class Car extends React.Component {
+ constructor(props) {
+ super(props);
+ this.state = { brand: 'Ford' };
+ }
+ render() {
+ return (
+ <div>
+ <h1>My Car</h1>
+ </div>
+ );
+ }
+}
+```
+
+#### JSX
+
+JSX is a syntax extension to JavaScript. It is similar to a template language but has the full power of JavaScript. JSX is compiled to `React.createElement()` calls, which return plain JavaScript objects called _React elements_. For example:
+
+
+```
+return (
+ <div>
+ <h1>My Car</h1>
+ </div>
+);
+```
+
+The code between the return method that looks like HTML is JSX.
+
+### How to use React
+
+Ready to get started? I'll go step-by-step through two options for using React in your app:
+
+ * Adding its content delivery network (CDN) to your HTML file
+ * Starting a blank React app with Create React App
+
+
+
+#### Add its CDN to your HTML file
+
+You can quickly use React in your HTML page by adding its CDN directly to your HTML file using the following steps:
+
+**Step 1:** In the HTML page you want to add React to, add an empty `` tag to create a container where you want to render something with React. For example:
+
+
+```
+<!-- ... old HTML ... -->
+
+<[div][10] id="button_container"></[div][10]>
+
+<!-- ... old HTML ... -->
+```
+
+**Step 2:** Add three `