-
Notifications
You must be signed in to change notification settings - Fork 21
/
Copy pathArticles.txt
224 lines (137 loc) · 11.4 KB
/
Articles.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
Please send some articals to this also:
<---------------------First Article---------------------------->
Marcus Geduld
Marcus Geduld, 30 years of coding.
Updated Aug 11, 2015 · Upvoted by Martin Krämer, MSc in CS '07. Worked since then as SE with a 2-3 year break doing ML research.
Originally Answered: What is Git used for? What does it do exactly?
Git allows a team of people to work together, all using the same files. And it helps the team cope with the confusion that tends to happen when multiple people are editing the same files.
There are many ways it can be set up and configured, but at my job, here's how we use it: when a new employee starts, he downloads all the files from Github, which is an online server we're all connected to.
So he has his local version of the files, I have my local version, our boss has his local version, etc.
When I make a change to some files, I go through the following process in the Terminal. (There are GUI clients for Git, but I prefer working on the command line.)
> git pull
That pulls the latest changes down from github. If there are conflicts between those and my local ones, it tells me what they are, file-by-file, line-by-line, and I now have a chance to reconcile those differences.
After editing the files or creating new ones, I run this command:
> git add .
Which adds all of my local changes to git, so that git knows about them. The dot after add specifically means to add all the changes I've made, e.g. new files I've added to my local folder or changes I've made to existing files. If I want, I can add only specific files, e.g.
> git add myNewFile.js
I now write a comment about the adds I just made.
> git commit -m "Fixed a major bug which stopped reports from printing."
Finally, I upload my changes to the server.
> git push
Now, when my colleagues do a ...
> git pull
... they will get my changes, and they will be notified if any of them conflict with their local versions.
There are all kinds of cool, useful commands for rolling back changes to a particular time or state. But probably the most useful thing about Git is branching. Let's say my team is working on code for an Asteroids game, and I get the idea for making spinning asteroids. This will involve making some major changes to the existing asteroids code, and I'm a little scared to do that. No worries, I can just make a branch.
First of all, I'll check which branches exist:
> git branch
master*
So there's currently only one branch on my local machine, called master. The star by it means that's the branch I'm currently working in. I'll go ahead and create a new one:
> git branch spinningAsteroids
That creates a copy of all the files in master. I'll now move into that branch.
> git checkout spinningAsteroids
> git branch
master
spinningAsteroids*
I now spend a couple of hours in spinningAsteroids, doing whatever coding I need to do, not worrying about messing things up, because I'm in a branch. Meanwhile, I get a tech support call. They've found a critical bug and I need to fix it asap. No worries...
> git checkout master
... fix bug ...
> git pull
> git add .
> git commit -m "Fixed critical bug with high scores."
> git push
Now I can resume my work with spinningAsteroids.
> git checkout spinningAsteroids
> git branch
master
spinningAsteroids*
... work, work, work ...
Okay, I'm now happy with my spinning asteroids, and I want to merge that new code into the main code base, so...
> git checkout master
> git branch
master*
spinningAsteroids
> git merge spinningAsteroids
Now the code from my branch is merged into the main code-base. I can now upload it.
> git pull
> git add .
> git commit -m "added new cool feature! Spinning asteroids!!!"
> git push
There are many ways to use Git. This is just one of them
<-------------------------END------------------------->
<--------ashwani second article------->
What is GitHub?
GitHub is a code hosting platform for version control and collaboration. It lets you and others work together on projects from anywhere.
This tutorial teaches you GitHub essentials like repositories, branches, commits, and Pull Requests. You’ll create your own Hello World repository and learn GitHub’s Pull Request workflow, a popular way to create and review code.
No coding necessary
To complete this tutorial, you need a GitHub.com account and Internet access. You don’t need to know how to code, use the command line, or install Git (the version control software GitHub is built on).
Tip: Open this guide in a separate browser window (or tab) so you can see it while you complete the steps in the tutorial.
<<---------------end ----------------->>
<-------------------------------Google Guava Library for Java---------------------------->
The Guava project contains several of Google's core libraries that we rely on in our Java-based projects: collections, caching, primitives support, concurrency libraries, common annotations, string processing, I/O, and so forth. Each of these tools really do get used every day by Googlers, in production services.
But trawling through Javadoc isn't always the most effective way to learn how to make best use of a library. Here, we try to provide readable and pleasant explanations of some of the most popular and most powerful features of Guava.
This wiki is a work in progress, and parts of it may still be under construction.
Basic utilities: Make using the Java language more pleasant.
Using and avoiding null: null can be ambiguous, can cause confusing errors, and is sometimes just plain unpleasant. Many Guava utilities reject and fail fast on nulls, rather than accepting them blindly.
Preconditions: Test preconditions for your methods more easily.
Common object methods: Simplify implementing Object methods, like hashCode() and toString().
Ordering: Guava's powerful "fluent Comparator" class.
Throwables: Simplify propagating and examining exceptions and errors.
Collections: Guava's extensions to the JDK collections ecosystem. These are some of the most mature and popular parts of Guava.
Immutable collections, for defensive programming, constant collections, and improved efficiency.
New collection types, for use cases that the JDK collections don't address as well as they could: multisets, multimaps, tables, bidirectional maps, and more.
Powerful collection utilities, for common operations not provided in java.util.Collections.
Extension utilities: writing a Collection decorator? Implementing Iterator? We can make that easier.
Caches: Local caching, done right, and supporting a wide variety of expiration behaviors.
Functional idioms: Used sparingly, Guava's functional idioms can significantly simplify code.
Concurrency: Powerful, simple abstractions to make it easier to write correct concurrent code.
ListenableFuture: Futures, with callbacks when they are finished.
Service: Things that start up and shut down, taking care of the difficult state logic for you.
Strings: A few extremely useful string utilities: splitting, joining, padding, and more.
Primitives: operations on primitive types, like int and char, not provided by the JDK, including unsigned variants for some types.
Ranges: Guava's powerful API for dealing with ranges on Comparable types, both continuous and discrete.
I/O: Simplified I/O operations, especially on whole I/O streams and files, for Java 5 and 6.
Hashing: Tools for more sophisticated hashes than what's provided by Object.hashCode(), including Bloom filters.
EventBus: Publish-subscribe-style communication between components without requiring the components to explicitly register with one another.
Math: Optimized, thoroughly tested math utilities not provided by the JDK.
Reflection: Guava utilities for Java's reflective capabilities.
Tips: Getting your application working the way you want it to with Guava.
Philosophy: what Guava is and isn't, and our goals.
Using Guava in your build, with build systems including Maven, Gradle, and more.
Using ProGuard to avoid bundling parts of Guava you don't use with your JAR.
Apache Commons equivalents, helping you translate code from using Apache Commons Collections.
Compatibility, details between Guava versions.
Idea Graveyard, feature requests that have been conclusively rejected.
Friends, open-source projects we like and admire.
HowToContribute, how to contribute to Guava.
<--------------------------------------End-------------------------------------->
<-------------------------------------Fourth Artical---------------------------->
Django (/ˈdʒæŋɡoʊ/ JANG-goh)[4] is a free and open-source web framework, written in Python, which follows the model-view-template
(MVT) architectural pattern.[5][6] It is maintained by the Django Software Foundation (DSF), an independent organization established
as a 501(c)(3) non-profit.
Django's primary goal is to ease the creation of complex, database-driven websites. Django emphasizes reusability and "pluggability"
of components, rapid development, and the principle of don't repeat yourself. Python is used throughout, even for settings files
and data models. Django also provides an optional administrative create, read, update and delete interface that is generated
dynamically through introspection and configured via admin models.
Some well-known sites that use Django include the Public Broadcasting Service,[7] Pinterest,[8] Instagram,[9] Mozilla,[10]
The Washington Times,[11] Disqus,[12] Bitbucket,[13] and Nextdoor.[14]
<---------------------------------------End---------------------------------->
<----------------------------------JSF FrameWork------------------------------>
JavaServer Faces (JSF) is a Java specification for building component-based user interfaces for web applications.[1] It was formalized as a standard through the Java Community Process and is part of the Java Platform, Enterprise Edition.
JSF 2 uses Facelets as its default templating system. Other view technologies such as XUL or plain Java[2] can also be employed. In contrast, JSF 1.x uses JavaServer Pages (JSP) as its default templating system.
HOW IT WORKS?
Based on a component-driven UI design-model, JavaServer Faces uses XML files called view templates or Facelets views. The FacesServlet processes requests, loads the appropriate view template, builds a component tree, processes events, and renders the response (typically in the HTML language) to the client. The state of UI components and other objects of scope interest is saved at the end of each request in a process called stateSaving (note: transient true), and restored upon next creation of that view. Either the client or the server side can save objects and states.
<------------------------------------End-------------------------------------->
--------------------------------------------------------------------------------
TEST EDIT - 27/9/2016
Aurio
---------------------------------------End---------------------------------------
--------------------------------------Useless Rant--------------------------------
$ git remote -v
$ git pull upstream master
OR
$ git fetch upstream
$ git merge master upstream/master // Alternative : $ git rebase upstream/master
-Akshat
$we can use -v to know about any command in detail
-Nishant
---------------------------------------End-----------------------------------------