Get Mystery Box with random crypto!

Computer Science and Programming

Categories: Technologies
Language: English
Subscribers: 156.44K
Description from channel

Channel specialized for advanced topics of:
* Artificial intelligence,
* Machine Learning,
* Deep Learning,
* Computer Vision,
* Data Science
* Python
For Ads: @otchebuch & @cobbl, https://telega.io/c/computer_science_and_programming

Ratings & Reviews

4.00

2 reviews

Reviews can be left only by registered users. All reviews are moderated by admins.

5 stars

1

4 stars

0

3 stars

1

2 stars

0

1 stars

0


The latest Messages 6

2023-12-12 16:14:01
12 Microservices Best Practices You Should Know

1 - Single Responsibility
2 - Containers
3 - Orchestration
4 - Resilience and Fault Tolerance
5 - Scalability
6 - CI/CD
7 - Observability
8 - Security
9 - API Gateway
10 - Stateless
11 - DB Per Service
12 - Event Driven Architecture
16.1K views13:14
Open / Comment
2023-12-08 20:04:11
7 Popular Network Protocols

1- HTTPS: Secure version of HTTP, used for secure communication over a computer network.

2 - Web Socket: Provides full-duplex communication channels over a single TCP connection.

3 - TCP: Provides reliable, ordered, and error-checked delivery of a stream of bytes.

4 - HTTP: Foundation of any data exchange on the Web, a protocol used for transmitting hypertext.

5 - FTP: Used for the transfer of computer files between a client and server on a computer network.

6 - UDP: Allows computer applications to send messages, in this case referred to as datagrams, to other hosts on an Internet Protocol (IP) network.

7 - SMTP: Internet standard for email transmission across Internet Protocol (IP) networks.
17.6K views17:04
Open / Comment
2023-12-08 17:59:54 Make sure you're using a premium VPN!!

Download and use OrcaVPN and get:

VPN split tunnelling
Speed test
IP Checker
Ad blocker
High speed and low ping
Access restricted Apps

1 month
free with CODE: SECRET. Then only $4.99 $0.99


https://7etap.app.link/OrcaVPN
15.7K views14:59
Open / Comment
2023-12-06 22:03:49
Sharing the tool that will make working with text easier!

CMD+ helps to make your day-to-day tasks easier and faster while providing you with customization options so that you can tailor the interface to fit your needs. With just a few simple commands, you can easily take care of various tasks such as text writing, translation, Excel promts, and rephrasing, eliminating the hassle of manually doing those activities. By automating these time-consuming processes, CMD+ saves you time and energy, allowing you to focus on more important tasks.

Download:
https://cmdplus.page.link/H3Ed
13.8K views19:03
Open / Comment
2023-12-05 21:06:35
How do companies ship code to production?

Step 1: The process starts with a product owner creating user stories based on requirements.

Step 2: The dev team picks up the user stories from the backlog and puts them into a sprint for a two-week dev cycle.

Step 3: The developers commit source code into the code repository Git.

Step 4: A build is triggered in Jenkins. The source code must pass unit tests, code coverage threshold, and gates in SonarQube.

Step 5: Once the build is successful, the build is stored in artifactory. Then the build is deployed into the dev environment.

Step 6: There might be multiple dev teams working on different features. The features need to be tested independently, so they are deployed to QA1 and QA2.

Step 7: The QA team picks up the new QA environments and performs QA testing, regression testing, and performance testing.

Steps 8: Once the QA builds pass the QA team’s verification, they are deployed to the UAT environment.

Step 9: If the UAT testing is successful, the builds become release candidates and will be deployed to the production environment on schedule.

Step 10: SRE (Site Reliability Engineering) team is responsible for prod monitoring.
16.4K views18:06
Open / Comment
2023-12-03 21:49:01
The 12 Factor App is a methodology for building scalable and maintainable web applications. It provides a set of guidelines for developing modern, cloud-native, and containerized applications. Here are the 12 factors explained in bullet points:

1. Codebase:
- One codebase per application.
- Use version control to manage code changes.

2. Dependencies:
- Explicitly declare and isolate dependencies.
- Avoid relying on system-wide packages.

3. Config:
- Store configuration in environment variables.
- Keep configuration separate from code.

4. Backing Services:
- Treat external services (databases, caches, etc.) as attached resources.
- Connect to them via URLs or environment variables.

5. Build, Release, Run:
- Strictly separate the build, release, and run stages of the application.
- Use consistent and repeatable build processes.

6. Processes:
- Execute the application as stateless processes.
- Avoid storing session data locally; use external services.

7. Port Binding:
- Export services via a port and communicate over the network.
- Web applications should bind to a port defined by the environment.

8. Concurrency:
- Scale out via the process model.
- Utilize multiple stateless processes to handle requests.

9. Disposability:
- Maximize robustness with fast startup and graceful shutdown.
- Terminate unneeded processes without impact.

10. Dev/Prod Parity:
- Keep development, staging, and production environments as similar as possible.
- Use the same dependencies and configuration.

11. Logs:
- Treat logs as event streams.
- Write application logs to standard output and allow log aggregation.

12. Admin Processes:
- Run administrative tasks as one-off processes.
- Use the same codebase and environment for administrative tasks.

Adhering to these 12 factors helps create applications that are easier to develop, deploy, and maintain, making them well-suited for cloud-native and containerized environments.
15.6K views18:49
Open / Comment
2023-11-30 21:46:19
In the world of software development and system integration, the methods by which one system communicates with another can have a significant impact on the efficiency and responsiveness of the overall process. Two common approaches to this communication are polling and webhooks.

In the context of software, webhooks are HTTP callbacks that allow one system to notify another system of an event as soon as it happens. In the VCS and CI/CD scenario:

1. The VCS, such as GitHub, Bitbucket, or GitLab, has a webhook feature.
2. Whenever a code push occurs, the VCS sends an immediate HTTP POST request to the CI/CD server, saying, "Hey, new code just arrived!"
3. The CI/CD server responds instantly, starting the build and deployment process without wasting time checking repeatedly.

Here is a simplified example

Polling:
Imagine you're waiting for an important text message from a friend. To check if the message has arrived, you periodically take out your phone, unlock it, and open the messaging app to see if there's a new message. You keep doing this every few minutes until you finally see the message. This process is similar to polling in the context of software systems.

In software, polling is a method where a system (e.g., a Continuous Integration/Continuous Deployment server) repeatedly checks another system (e.g., a Version Control System) for updates. In your VCS and CI/CD scenario, it works like this:

1. CI/CD server regularly checks the VCS repository for code changes.
2. It repeatedly asks, "Is there new code? Is there new code?"
3. When it detects new code, it triggers the build and deployment process.

Webhooks:
Now, imagine you have a special notification setup with your friend. Instead of repeatedly checking your phone, your friend promises to send you a message as soon as anything important happens. So, you can put your phone aside and carry on with other tasks, only looking at it when you receive a notification. This is analogous to webhooks.
15.9K views18:46
Open / Comment
2023-11-27 11:09:01
12 Design Patterns You Must Know

1. Factory Pattern
Imagine a factory that produces different products. Similarly, this pattern creates objects without specifying their exact class, making code flexible and extendable.

2. Observer Pattern
Like subscribing to updates! Objects (observers) register to watch changes in a subject. When the subject changes, observers are notified automatically.

3. Singleton Pattern
Ensures a class has only one instance globally accessible. Useful for managing shared resources like databases.

4. Builder Pattern
Building complex objects step by step. Think of it as assembling Lego bricks to create something intricate without the mess!

5. Adapter Pattern
Converts the interface of one class into another interface clients expect. Makes incompatible components work together.

6. Decorator Pattern
Like adding toppings to your pizza! Dynamically adds responsibilities to objects without changing their code. A flexible alternative to subclassing.

7. Proxy Pattern
Controls access to an object, acting as a stand-in with additional functionality, like lazy loading.

8. Strategy Pattern
Switching strategies seamlessly! Allows selecting algorithms during runtime. Useful when you want to provide multiple ways to accomplish a task.

9. Command Pattern
Encapsulates requests as objects, allowing parameterization of clients with different requests and queuing of requests. Think of it as a to-do list for your program.

10. Template Pattern
Standardized process steps! Defines the structure of an algorithm, letting subclasses override specific steps. Ideal for reusable workflows.

11. Iterator Pattern
Tour guide for collections! Provides a way to access elements of a collection without exposing its underlying representation.

12. State Pattern
Like a traffic light! Allows an object to change its behavior when its internal state changes. Keeps your code organized as states pile up.
18.8K views08:09
Open / Comment
2023-11-24 22:22:01
5 books for Software Engineers

1. Clean Architecture (Martin)
2. Building Microservices (Newman)
3. Unit Testing (Khorikov)
4. Domain Driven Design (Evans)
5. Head First Design Patterns (Freeman & Robson)

What is your favourite? Comment bellow.
18.1K views19:22
Open / Comment
2023-11-21 16:14:01
6 API Architectural designs You Must Know

1. REST
Representational State Transfer - REST is like a classic library where you request specific books and receive them as they are. It's simple and widely used for web APIs, like ordering a la carte from a menu .

2. GraphQL
GraphQL is like a customizable buffet where you ask for exactly what you want and get a tailored plate. It allows clients to request only the data they need, reducing over-fetching.

3. SOAP
SOAP (Simple Object Access Protocol) is like sending a letter with detailed instructions, complete with a table of contents. It's more structured but can be heavier than REST or GraphQL.

4. gRPC :
gRPC is like a high-speed train for communication between services. It uses Protocol Buffers for efficient data exchange and supports streaming and bidirectional communication.

5. WebSockets
WebSockets are like real-time phone calls for the web. They enable two-way communication, perfect for chat apps and live updates.

6. MQTT
MQTT (Message Queuing Telemetry Transport) is like a radio broadcast , designed for low-bandwidth, high-latency, or unreliable networks. Ideal for IoT devices and sensor data.
20.4K views13:14
Open / Comment