Speaking about Point 2 (http://linuxcommand.org), it’s quite difficult to read everything, but for me it was very convenient to use the format of tables with expressions, directories and wildcards and their explanations during reading.
And what about my feelings...
Working with GitHub and Git was new experience for me. Since I worked on my projects almost by myself. Incredibly convenient thing, and most importantly, I felt the optimization of even small details of this tool . The course is interesting , I like the moment that you need to work with the repository by yourself.
Some things were shocking, for example : 
But in any case, it is very interesting.
So I will continue, thanks!
Questions:
- Stack Overflow and after it segmentation fault wiil be recieved.
- Will be created an anonymous memory mapping.
- Text memory segment is read only and stores data as a string literals. Data memory is read and write and saving the contents for static variables initialized in source code.
556528b6a000-556528b86000 r-xp 00000000 103:01 2621474 /bin/dash
556528d85000-556528d87000 r--p 0001b000 103:01 2621474 /bin/dash
556528d87000-556528d88000 rw-p 0001d000 103:01 2621474 /bin/dash
556528d88000-556528d8a000 rw-p 00000000 00:00 0
556529c01000-556529c22000 rw-p 00000000 00:00 0 [heap]
7f77d1ded000-7f77d1fd4000 r-xp 00000000 103:01 3674829 /lib/x86_64-linux-gnu/libc-2.27.so
7f77d1fd4000-7f77d21d4000 ---p 001e7000 103:01 3674829 /lib/x86_64-linux-gnu/libc-2.27.so
7f77d21d4000-7f77d21d8000 r--p 001e7000 103:01 3674829 /lib/x86_64-linux-gnu/libc-2.27.so
7f77d21d8000-7f77d21da000 rw-p 001eb000 103:01 3674829 /lib/x86_64-linux-gnu/libc-2.27.so
7f77d21da000-7f77d21de000 rw-p 00000000 00:00 0
7f77d21de000-7f77d2205000 r-xp 00000000 103:01 3674801 /lib/x86_64-linux-gnu/ld-2.27.so
7f77d23e6000-7f77d23e8000 rw-p 00000000 00:00 0
7f77d2405000-7f77d2406000 r--p 00027000 103:01 3674801 /lib/x86_64-linux-gnu/ld-2.27.so
7f77d2406000-7f77d2407000 rw-p 00028000 103:01 3674801 /lib/x86_64-linux-gnu/ld-2.27.so
7f77d2407000-7f77d2408000 rw-p 00000000 00:00 0
7ffe39224000-7ffe39246000 rw-p 00000000 00:00 0 [stack]
7ffe393ea000-7ffe393ed000 r--p 00000000 00:00 0 [vvar]
7ffe393ed000-7ffe393ee000 r-xp 00000000 00:00 0 [vdso]
ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]
Heap - 556529c01000-556529c22000, Stack - 7ffe39224000-7ffe39246000, MMS - 556528d88000-556528d8a000.
Regarding the topic: The first article was very difficult for me. I used additional articles and videos to understand how the memory management tool works. The task was quite simple.
Internet101: Very nice course in terms of presentation and animation, it was nice to watch, especially at the weekend.
howdns.works: Perhaps the most interesting material that I saw on this topic.
Networking for Web Developers: I worked very little with Linux, so this course, in general, was difficult, but useful.
TCP sniffer: here
- curl https://api.github.com/users/MikeYatsenko
- curl-i https://api.github.com/users/MikeYatsenko
- curl --user "MikeYatsenko:BLABLABLA" https://api.github.com/gists/starred
- curl --user "MikeYatsenko:*********" https://api.github.com/gists/starred
- curl --user "MikeYatsenko" https://api.github.com/gists/starred
- curl -i https://api.github.com/orgs/kottans/repos
- curl -H 'Authorization:*********' https://api.github.com/repos/MikeYatsenko/kottans-backend/issues -d '{"title": "Test Issue"}'
Questions:
1. Name at least three possible negative consequences of not using HTTPS.
HTTPS is a protocol that involves the use of a certificate, which creates a secure encrypted connection between the web server and the web browser.
- Data is not encrypted, and it can be intercepted by third parties to gather data being passed between the two systems.
- You can lose data integrity. SSL and TLS provide data integrity by calculating a message digest.
- Encrypting a communication is good but it is not enough, you need to be confident about that you are talking to the right person or the right server. So you need to use identification provided by certificate.
2. Explain the main idea behind public key cryptography in few sentences.
TLS is a hybrid cryptographic system. This means that it uses several cryptographic approaches, which we will consider further:
- Asymmetric encryption (a public-key cryptosystem) for generating a shared secret key and authentication (that is, verifying that you are the one who claims to be).
- Symmetric encryption using a secret key for further encryption of requests and responses.
The public key is used to encrypt the message text in characters, while the private key is used to decrypt and retrieve the source text. Since the message has been encrypted using the public key, it can only be decrypted with the corresponding private key. None of the keys can perform both functions. The public key is published in the public domain without risking exposing the system to threats, but the private key should not reach anyone who does not have the right to decrypt data.
3. An application for pet clinic.
- POST, add new pet, response will be status 201.
- GET, search pet by name, response will be status 200.
- PUT, change name of an existing pet, response will be status 200.
- PUT, add new info about pet's health, response will be status 200.
- PUT, assign a pet to a particular doctor, response will be status 200.
- PUT, register an appointment for a pet, response will be status 200.
What I, as a beginner, understood about design patterns: it's a general concept for solving a particular problem that will need to be further adjusted to the needs of your code. The pattern is usually described through:
- class structures that make up the solution.
- an example in programming language.
- implementation features in various contexts.
- links to other patterns.
For Python, as for a highly developed language, a large number of patterns are compiled, we can see it in one of the articles in the task.
The course, which was also presented in the task, initially defines common approaches to software design using a browser as an example. After this, teacher explaine us about the UCL which can be used for object-oriented analysis and design and OCL (declarative language describing rules applying to UCL). The course further explains the approaches to using patterns in OOP and and decisions about choosing the necessary patterns.
